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

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

202 files changed, 40615 insertions, 0 deletions

diff --git a/comm/calendar/test/.eslintrc.js b/comm/calendar/test/.eslintrc.js
new file mode 100644
index 0000000000..fc89c84bb1
--- /dev/null
+++ b/comm/calendar/test/.eslintrc.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/. */
+
+"use strict";
+
+// Calendar tests run with the pref calendar.timezone.local set to UTC. This
+// works fine on the CI, where the system clock is also UTC, but on developers'
+// machines the time difference causes some problems. If you have to use the
+// Date object, make sure that you use UTC methods.
+
+module.exports = {
+  rules: {
+    "no-restricted-properties": [
+      "error",
+      {
+        property: "getFullYear",
+        message: "These tests run in UTC. Use 'getUTCFullYear' instead.",
+      },
+      {
+        property: "getMonth",
+        message: "These tests run in UTC. Use 'getUTCMonth' instead.",
+      },
+      {
+        property: "getDay",
+        message: "These tests run in UTC. Use 'getUTCDay' instead.",
+      },
+      {
+        property: "getDate",
+        message: "These tests run in UTC. Use 'getUTCDate' instead.",
+      },
+      {
+        property: "getHours",
+        message: "These tests run in UTC. Use 'getUTCHours' instead.",
+      },
+      {
+        property: "getMinutes",
+        message: "These tests run in UTC. Use 'getUTCMinutes' instead.",
+      },
+      {
+        property: "setFullYear",
+        message: "These tests run in UTC. Use 'setUTCFullYear' instead.",
+      },
+      {
+        property: "setMonth",
+        message: "These tests run in UTC. Use 'setUTCMonth' instead.",
+      },
+      {
+        property: "setDay",
+        message: "These tests run in UTC. Use 'setUTCDay' instead.",
+      },
+      {
+        property: "setDate",
+        message: "These tests run in UTC. Use 'setUTCDate' instead.",
+      },
+      {
+        property: "setHours",
+        message: "These tests run in UTC. Use 'setUTCHours' instead.",
+      },
+      {
+        property: "setMinutes",
+        message: "These tests run in UTC. Use 'setUTCMinutes' instead.",
+      },
+    ],
+    "no-restricted-syntax": [
+      "error",
+      {
+        selector: "[callee.name='Date'][arguments.length>=2]",
+        message:
+          "These tests run in UTC. Use 'new Date(Date.UTC(...))' to construct a Date with arguments.",
+      },
+    ],
+  },
+};
diff --git a/comm/calendar/test/CalDAVServer.jsm b/comm/calendar/test/CalDAVServer.jsm
new file mode 100644
index 0000000000..aff2242f43
--- /dev/null
+++ b/comm/calendar/test/CalDAVServer.jsm
@@ -0,0 +1,627 @@
+/* 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 EXPORTED_SYMBOLS = ["CalDAVServer"];
+
+const PREFIX_BINDINGS = {
+  c: "urn:ietf:params:xml:ns:caldav",
+  cs: "http://calendarserver.org/ns/",
+  d: "DAV:",
+  i: "http://apple.com/ns/ical/",
+};
+const NAMESPACE_STRING = Object.entries(PREFIX_BINDINGS)
+  .map(([prefix, url]) => `xmlns:${prefix}="${url}"`)
+  .join(" ");
+
+const { Assert } = ChromeUtils.importESModule("resource://testing-common/Assert.sys.mjs");
+const { CommonUtils } = ChromeUtils.importESModule("resource://services-common/utils.sys.mjs");
+const { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
+
+const logger = console.createInstance({
+  prefix: "CalDAVServer",
+  maxLogLevel: "Log",
+});
+
+// The response bodies Google sends if you exceed its rate limit.
+let MULTIGET_RATELIMIT_ERROR = `<?xml version="1.0" encoding="UTF-8"?>
+<D:error xmlns:D="DAV:"/>
+`;
+let PROPFIND_RATELIMIT_ERROR = `<?xml version="1.0" encoding="UTF-8"?>
+<errors xmlns="http://schemas.google.com/g/2005">
+ <error>
+  <domain>GData</domain>
+  <code>rateLimitExceeded</code>
+  <internalReason>Some text we're not looking at anyway</internalReason>
+ </error>
+</errors>
+`;
+
+var CalDAVServer = {
+  items: new Map(),
+  deletedItems: new Map(),
+  changeCount: 0,
+  server: null,
+  isOpen: false,
+
+  /**
+   * The "current-user-privilege-set" in responses. Set to null to have no privilege set.
+   */
+  privileges: "<d:privilege><d:all/></d:privilege>",
+
+  open(username, password) {
+    this.server = new HttpServer();
+    this.server.start(-1);
+    this.isOpen = true;
+
+    this.username = username;
+    this.password = password;
+    this.server.registerPathHandler("/ping", this.ping);
+
+    this.reset();
+  },
+
+  reset() {
+    this.items.clear();
+    this.deletedItems.clear();
+    this.changeCount = 0;
+    this.privileges = "<d:privilege><d:all/></d:privilege>";
+    this.resetHandlers();
+  },
+
+  resetHandlers() {
+    this.server.registerPathHandler("/.well-known/caldav", this.wellKnown.bind(this));
+    this.server.registerPathHandler("/principals/", this.principals.bind(this));
+    this.server.registerPathHandler("/principals/me/", this.myPrincipal.bind(this));
+    this.server.registerPathHandler("/calendars/me/", this.myCalendars.bind(this));
+
+    this.server.registerPathHandler(this.path, this.directoryHandler.bind(this));
+    this.server.registerPrefixHandler(this.path, this.itemHandler.bind(this));
+  },
+
+  close() {
+    if (!this.isOpen) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve =>
+      this.server.stop({
+        onStopped: () => {
+          this.isOpen = false;
+          resolve();
+        },
+      })
+    );
+  },
+
+  get origin() {
+    return `http://localhost:${this.server.identity.primaryPort}`;
+  },
+
+  get path() {
+    return "/calendars/me/test/";
+  },
+
+  get url() {
+    return `${this.origin}${this.path}`;
+  },
+
+  get altPath() {
+    return "/addressbooks/me/default/";
+  },
+
+  get altURL() {
+    return `${this.origin}${this.altPath}`;
+  },
+
+  checkAuth(request, response) {
+    if (!this.username || !this.password) {
+      return true;
+    }
+    if (!request.hasHeader("Authorization")) {
+      response.setStatusLine("1.1", 401, "Unauthorized");
+      response.setHeader("WWW-Authenticate", `Basic realm="test"`);
+      return false;
+    }
+
+    let value = request.getHeader("Authorization");
+    if (!value.startsWith("Basic ")) {
+      response.setStatusLine("1.1", 401, "Unauthorized");
+      response.setHeader("WWW-Authenticate", `Basic realm="test"`);
+      return false;
+    }
+
+    let [username, password] = atob(value.substring(6)).split(":");
+    if (username != this.username || password != this.password) {
+      response.setStatusLine("1.1", 401, "Unauthorized");
+      response.setHeader("WWW-Authenticate", `Basic realm="test"`);
+      return false;
+    }
+
+    return true;
+  },
+
+  ping(request, response) {
+    response.setStatusLine("1.1", 200, "OK");
+    response.setHeader("Content-Type", "text/plain");
+    response.write("pong");
+  },
+
+  wellKnown(request, response) {
+    response.setStatusLine("1.1", 301, "Moved Permanently");
+    response.setHeader("Location", "/principals/");
+  },
+
+  principals(request, response) {
+    if (!this.checkAuth(request, response)) {
+      return;
+    }
+
+    let input = new DOMParser().parseFromString(
+      CommonUtils.readBytesFromInputStream(request.bodyInputStream),
+      "text/xml"
+    );
+
+    let propNames = this._inputProps(input);
+    let propValues = {
+      "d:current-user-principal": "<href>/principals/me/</href>",
+    };
+
+    response.setStatusLine("1.1", 207, "Multi-Status");
+    response.setHeader("Content-Type", "text/xml");
+    response.write(
+      `<multistatus xmlns="${PREFIX_BINDINGS.d}" ${NAMESPACE_STRING}>
+        <response>
+          <href>/principals/</href>
+          ${this._outputProps(propNames, propValues)}
+        </response>
+      </multistatus>`.replace(/>\s+</g, "><")
+    );
+  },
+
+  myPrincipal(request, response) {
+    if (!this.checkAuth(request, response)) {
+      return;
+    }
+
+    let input = new DOMParser().parseFromString(
+      CommonUtils.readBytesFromInputStream(request.bodyInputStream),
+      "text/xml"
+    );
+
+    let propNames = this._inputProps(input);
+    let propValues = {
+      "d:resourcetype": "<principal/>",
+      "c:calendar-home-set": "<d:href>/calendars/me/</d:href>",
+      "c:calendar-user-address-set": `<d:href preferred="1">mailto:me@invalid</d:href>`,
+      "c:schedule-inbox-URL": "<d:href>/calendars/me/inbox/</d:href>",
+      "c:schedule-outbox-URL": "<d:href>/calendars/me/inbox/</d:href>",
+    };
+
+    response.setStatusLine("1.1", 207, "Multi-Status");
+    response.setHeader("Content-Type", "text/xml");
+    response.write(
+      `<multistatus xmlns="${PREFIX_BINDINGS.d}" ${NAMESPACE_STRING}>
+        <response>
+          <href>/principals/me/</href>
+          ${this._outputProps(propNames, propValues)}
+        </response>
+      </multistatus>`.replace(/>\s+</g, "><")
+    );
+  },
+
+  myCalendars(request, response) {
+    if (!this.checkAuth(request, response)) {
+      return;
+    }
+
+    if (request.method == "OPTIONS") {
+      response.setStatusLine("1.1", 200, "OK");
+      response.setHeader("DAV", "1,2,3, calendar-access, calendar-schedule");
+      return;
+    }
+
+    let input = new DOMParser().parseFromString(
+      CommonUtils.readBytesFromInputStream(request.bodyInputStream),
+      "text/xml"
+    );
+
+    let propNames = this._inputProps(input);
+    let propValues = {
+      "d:resourcetype": "<collection/><c:calendar/>",
+      "d:displayname": "CalDAV Test",
+      "i:calendar-color": "#ff8000",
+      "d:current-user-privilege-set": this.privileges,
+    };
+
+    response.setStatusLine("1.1", 207, "Multi-Status");
+    response.setHeader("Content-Type", "text/xml");
+    response.write(
+      `<multistatus xmlns="${PREFIX_BINDINGS.d}" ${NAMESPACE_STRING}>
+        <response>
+          <href>/addressbooks/me/</href>
+          ${this._outputProps(propNames, {
+            "d:resourcetype": "<collection/>",
+            "d:displayname": "#calendars",
+          })}
+        </response>
+        <response>
+          <href>${this.path}</href>
+          ${this._outputProps(propNames, propValues)}
+        </response>
+      </multistatus>`.replace(/>\s+</g, "><")
+    );
+  },
+
+  /** Handle any requests to the calendar itself. */
+
+  directoryHandler(request, response) {
+    if (!this.checkAuth(request, response)) {
+      return;
+    }
+
+    if (request.method == "OPTIONS") {
+      response.setStatusLine("1.1", 204, "No Content");
+      return;
+    }
+
+    let input = CommonUtils.readBytesFromInputStream(request.bodyInputStream);
+    logger.log("C: " + input);
+    input = new DOMParser().parseFromString(input, "text/xml");
+
+    switch (input.documentElement.localName) {
+      case "calendar-query":
+        Assert.equal(request.method, "REPORT");
+        Assert.equal(input.documentElement.namespaceURI, PREFIX_BINDINGS.c);
+        this.calendarQuery(input, response);
+        return;
+      case "calendar-multiget":
+        Assert.equal(request.method, "REPORT");
+        Assert.equal(input.documentElement.namespaceURI, PREFIX_BINDINGS.c);
+        this.calendarMultiGet(input, response);
+        return;
+      case "propfind":
+        Assert.equal(request.method, "PROPFIND");
+        Assert.equal(input.documentElement.namespaceURI, PREFIX_BINDINGS.d);
+        this.propFind(input, request.hasHeader("Depth") ? request.getHeader("Depth") : 0, response);
+        return;
+      case "sync-collection":
+        Assert.equal(request.method, "REPORT");
+        Assert.equal(input.documentElement.namespaceURI, PREFIX_BINDINGS.d);
+        this.syncCollection(input, response);
+        return;
+    }
+
+    Assert.report(true, undefined, undefined, "Should not have reached here");
+    response.setStatusLine("1.1", 404, "Not Found");
+    response.setHeader("Content-Type", "text/plain");
+    response.write(`No handler found for <${input.documentElement.localName}>`);
+  },
+
+  calendarQuery(input, response) {
+    let propNames = this._inputProps(input);
+    let output = `<multistatus xmlns="${PREFIX_BINDINGS.d}" ${NAMESPACE_STRING}>`;
+    for (let [href, item] of this.items) {
+      output += this._itemResponse(href, item, propNames);
+    }
+    output += `</multistatus>`;
+
+    response.setStatusLine("1.1", 207, "Multi-Status");
+    response.setHeader("Content-Type", "text/xml");
+    response.write(output.replace(/>\s+</g, "><"));
+    logger.log("S: " + output.replace(/>\s+</g, "><"));
+  },
+
+  async calendarMultiGet(input, response) {
+    let propNames = this._inputProps(input);
+    let output = `<multistatus xmlns="${PREFIX_BINDINGS.d}" ${NAMESPACE_STRING}>`;
+    for (let href of input.querySelectorAll("href")) {
+      href = href.textContent;
+      let item = this.items.get(href);
+      if (item) {
+        output += this._itemResponse(href, item, propNames);
+      }
+    }
+    output += `</multistatus>`;
+
+    response.setStatusLine("1.1", 207, "Multi-Status");
+    response.setHeader("Content-Type", "text/xml");
+    response.write(output.replace(/>\s+</g, "><"));
+    logger.log("S: " + output.replace(/>\s+</g, "><"));
+  },
+
+  propFind(input, depth, response) {
+    if (this.throwRateLimitErrors) {
+      response.setStatusLine("1.1", 403, "Forbidden");
+      response.setHeader("Content-Type", "text/xml");
+      response.write(PROPFIND_RATELIMIT_ERROR);
+      logger.log("S: " + PROPFIND_RATELIMIT_ERROR);
+      return;
+    }
+
+    let propNames = this._inputProps(input);
+    let propValues = {
+      "d:resourcetype": "<d:collection/><c:calendar/>",
+      "d:owner": "/principals/me/",
+      "d:current-user-principal": "<href>/principals/me/</href>",
+      "d:current-user-privilege-set": this.privileges,
+      "d:supported-report-set":
+        "<d:supported-report><d:report><c:calendar-multiget/></d:report></d:supported-report>" +
+        "<d:supported-report><d:report><sync-collection/></d:report></d:supported-report>",
+      "c:supported-calendar-component-set": "",
+      "d:getcontenttype": "text/calendar; charset=utf-8",
+      "c:calendar-home-set": `<d:href>/calendars/me/</d:href>`,
+      "c:calendar-user-address-set": `<d:href preferred="1">mailto:me@invalid</d:href>`,
+      "c:schedule-inbox-url": `<d:href>/calendars/me/inbox/</d:href>`,
+      "c:schedule-outbox-url": `<d:href>/calendars/me/outbox/</d:href>`,
+      "cs:getctag": this.changeCount,
+      "d:getetag": this.changeCount,
+    };
+
+    let output = `<multistatus xmlns="${PREFIX_BINDINGS.d}" ${NAMESPACE_STRING}>
+      <response>
+        <href>${this.path}</href>
+        ${this._outputProps(propNames, propValues)}
+      </response>`;
+    if (depth == 1) {
+      for (let [href, item] of this.items) {
+        output += this._itemResponse(href, item, propNames);
+      }
+    }
+    output += `</multistatus>`;
+
+    response.setStatusLine("1.1", 207, "Multi-Status");
+    response.setHeader("Content-Type", "text/xml");
+    response.write(output.replace(/>\s+</g, "><"));
+    logger.log("S: " + output.replace(/>\s+</g, "><"));
+  },
+
+  syncCollection(input, response) {
+    if (this.throwRateLimitErrors) {
+      response.setStatusLine("1.1", 403, "Forbidden");
+      response.setHeader("Content-Type", "text/xml");
+      response.write(MULTIGET_RATELIMIT_ERROR);
+      logger.log("S: " + MULTIGET_RATELIMIT_ERROR);
+      return;
+    }
+
+    // The maximum number of responses to make at any one request.
+    let pageSize = 3;
+    // The last-seen token. Changes before this won't be returned.
+    let token = 0;
+    // Which page of responses to return.
+    let page = 0;
+
+    let tokenStr = input.querySelector("sync-token")?.textContent.replace(/.*\//g, "");
+    if (tokenStr?.includes("#")) {
+      [token, page] = tokenStr.split("#");
+      token = parseInt(token, 10);
+      page = parseInt(page, 10);
+    } else if (tokenStr) {
+      token = parseInt(tokenStr, 10);
+    }
+
+    let nextPage = page + 1;
+
+    // Collect all responses, even if we know some won't be returned.
+    // This is a test, who cares about performance?
+    let propNames = this._inputProps(input);
+    let responses = [];
+    for (let [href, item] of this.items) {
+      if (item.changed > token) {
+        responses.push(this._itemResponse(href, item, propNames));
+      }
+    }
+    for (let [href, deleted] of this.deletedItems) {
+      if (deleted > token) {
+        responses.push(`<response>
+          <status>HTTP/1.1 404 Not Found</status>
+          <href>${href}</href>
+          <propstat>
+            <prop/>
+            <status>HTTP/1.1 418 I'm a teapot</status>
+          </propstat>
+        </response>`);
+      }
+    }
+
+    let output = `<multistatus xmlns="${PREFIX_BINDINGS.d}" ${NAMESPACE_STRING}>`;
+    // Use only the responses that match those requested.
+    output += responses.slice(page * pageSize, nextPage * pageSize).join("");
+    if (responses.length > nextPage * pageSize) {
+      output += `<response>
+          <status>HTTP/1.1 507 Insufficient Storage</status>
+          <href>${this.path}</href>
+        </response>`;
+      output += `<sync-token>http://mochi.test/sync/${token}#${nextPage}</sync-token>`;
+    } else {
+      output += `<sync-token>http://mochi.test/sync/${this.changeCount}</sync-token>`;
+    }
+    output += `</multistatus>`;
+
+    response.setStatusLine("1.1", 207, "Multi-Status");
+    response.setHeader("Content-Type", "text/xml");
+    response.write(output.replace(/>\s+</g, "><"));
+    logger.log("S: " + output.replace(/>\s+</g, "><"));
+  },
+
+  _itemResponse(href, item, propNames) {
+    let propValues = {
+      "c:calendar-data": item.ics,
+      "d:getetag": item.etag,
+      "d:getcontenttype": "text/calendar; charset=utf-8; component=VEVENT",
+    };
+
+    let outString = `<response>
+      <href>${href}</href>
+      ${this._outputProps(propNames, propValues)}
+    </response>`;
+    return outString;
+  },
+
+  _inputProps(input) {
+    let props = input.querySelectorAll("prop > *");
+    let propNames = [];
+
+    for (let p of props) {
+      Assert.equal(p.childElementCount, 0);
+      switch (p.localName) {
+        case "calendar-home-set":
+        case "calendar-user-address-set":
+        case "schedule-inbox-URL":
+        case "schedule-outbox-URL":
+        case "supported-calendar-component-set":
+        case "calendar-data":
+          Assert.equal(p.namespaceURI, PREFIX_BINDINGS.c);
+          propNames.push(`c:${p.localName}`);
+          break;
+        case "getctag":
+          Assert.equal(p.namespaceURI, PREFIX_BINDINGS.cs);
+          propNames.push(`cs:${p.localName}`);
+          break;
+        case "getetag":
+        case "owner":
+        case "current-user-principal":
+        case "current-user-privilege-set":
+        case "supported-report-set":
+        case "displayname":
+        case "resourcetype":
+        case "sync-token":
+        case "getcontenttype":
+          Assert.equal(p.namespaceURI, PREFIX_BINDINGS.d);
+          propNames.push(`d:${p.localName}`);
+          break;
+        case "calendar-color":
+          Assert.equal(p.namespaceURI, PREFIX_BINDINGS.i);
+          propNames.push(`i:${p.localName}`);
+          break;
+        default:
+          Assert.report(true, undefined, undefined, `Unknown property requested: ${p.nodeName}`);
+          break;
+      }
+    }
+
+    return propNames;
+  },
+
+  _outputProps(propNames, propValues) {
+    let output = "";
+
+    let found = [];
+    let notFound = [];
+    for (let p of propNames) {
+      if (p in propValues && propValues[p] != null) {
+        found.push(`<${p}>${propValues[p]}</${p}>`);
+      } else {
+        notFound.push(`<${p}/>`);
+      }
+    }
+
+    if (found.length > 0) {
+      output += `<propstat>
+        <prop>
+          ${found.join("\n")}
+        </prop>
+        <status>HTTP/1.1 200 OK</status>
+      </propstat>`;
+    }
+    if (notFound.length > 0) {
+      output += `<propstat>
+        <prop>
+          ${notFound.join("\n")}
+        </prop>
+        <status>HTTP/1.1 404 Not Found</status>
+      </propstat>`;
+    }
+
+    return output;
+  },
+
+  /** Handle any requests to calendar items. */
+
+  itemHandler(request, response) {
+    if (!this.checkAuth(request, response)) {
+      return;
+    }
+
+    if (!/\/[\w-]+\.ics$/.test(request.path)) {
+      response.setStatusLine("1.1", 404, "Not Found");
+      response.setHeader("Content-Type", "text/plain");
+      response.write(`Item not found at ${request.path}`);
+      return;
+    }
+
+    switch (request.method) {
+      case "GET":
+        this.getItem(request, response);
+        return;
+      case "PUT":
+        this.putItem(request, response);
+        return;
+      case "DELETE":
+        this.deleteItem(request, response);
+        return;
+    }
+
+    Assert.report(true, undefined, undefined, "Should not have reached here");
+    response.setStatusLine("1.1", 405, "Method Not Allowed");
+    response.setHeader("Content-Type", "text/plain");
+    response.write(`Method not allowed: ${request.method}`);
+  },
+
+  async getItem(request, response) {
+    let item = this.items.get(request.path);
+    if (!item) {
+      response.setStatusLine("1.1", 404, "Not Found");
+      response.setHeader("Content-Type", "text/plain");
+      response.write(`Item not found at ${request.path}`);
+      return;
+    }
+
+    response.setStatusLine("1.1", 200, "OK");
+    response.setHeader("Content-Type", "text/calendar");
+    response.setHeader("ETag", item.etag);
+    response.write(item.ics);
+  },
+
+  async putItem(request, response) {
+    if (request.hasHeader("If-Match")) {
+      let item = this.items.get(request.path);
+      if (!item || item.etag != request.getHeader("If-Match")) {
+        response.setStatusLine("1.1", 412, "Precondition Failed");
+        return;
+      }
+    }
+
+    response.processAsync();
+
+    let ics = CommonUtils.readBytesFromInputStream(request.bodyInputStream);
+    await this.putItemInternal(request.path, ics);
+    response.setStatusLine("1.1", 204, "No Content");
+
+    response.finish();
+  },
+
+  async putItemInternal(name, ics) {
+    if (!name.startsWith("/")) {
+      name = this.path + name;
+    }
+
+    let hash = await crypto.subtle.digest("sha-1", new TextEncoder().encode(ics));
+    let etag = Array.from(new Uint8Array(hash), c => c.toString(16).padStart(2, "0")).join("");
+    this.items.set(name, { etag, ics, changed: ++this.changeCount });
+    this.deletedItems.delete(name);
+  },
+
+  deleteItem(request, response) {
+    this.deleteItemInternal(request.path);
+    response.setStatusLine("1.1", 204, "No Content");
+  },
+
+  deleteItemInternal(name) {
+    if (!name.startsWith("/")) {
+      name = this.path + name;
+    }
+    this.items.delete(name);
+    this.deletedItems.set(name, ++this.changeCount);
+  },
+};
diff --git a/comm/calendar/test/CalendarTestUtils.jsm b/comm/calendar/test/CalendarTestUtils.jsm
new file mode 100644
index 0000000000..42e587f540
--- /dev/null
+++ b/comm/calendar/test/CalendarTestUtils.jsm
@@ -0,0 +1,1203 @@
+/* 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/. */
+
+"use strict";
+
+const EXPORTED_SYMBOLS = ["CalendarTestUtils"];
+
+const EventUtils = ChromeUtils.import("resource://testing-common/mozmill/EventUtils.jsm");
+const { BrowserTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/BrowserTestUtils.sys.mjs"
+);
+const { TestUtils } = ChromeUtils.importESModule("resource://testing-common/TestUtils.sys.mjs");
+const { Assert } = ChromeUtils.importESModule("resource://testing-common/Assert.sys.mjs");
+const { cancelItemDialog, saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+const { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+async function clickAndWait(win, button) {
+  EventUtils.synthesizeMouseAtCenter(button, { clickCount: 1 }, win);
+  await new Promise(resolve => win.setTimeout(resolve));
+}
+
+/**
+ * @typedef EditItemAtResult
+ * @property {Window} dialogWindow - The window of the dialog.
+ * @property {Document} dialogDocument - The document of the dialog window.
+ * @property {Window} iframeWindow - The contentWindow property of the embedded
+ *  iframe.
+ * @property {Document} iframeDocument - The contentDocument of the embedded
+ *  iframe.
+ */
+
+/**
+ * Helper class for testing the day view of the calendar.
+ */
+class CalendarDayViewTestUtils {
+  #helper = new CalendarWeekViewTestUtils("#day-view");
+
+  /**
+   * Provides the column container element for the displayed day.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   *
+   * @returns {HTMLElement} - The column container element.
+   */
+  getColumnContainer(win) {
+    return this.#helper.getColumnContainer(win, 1);
+  }
+
+  /**
+   * Provides the element containing the formatted date for the displayed day.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   *
+   * @returns {HTMLElement} - The column heading container.
+   */
+  getColumnHeading(win) {
+    return this.#helper.getColumnHeading(win, 1);
+  }
+
+  /**
+   * Provides the calendar-event-column for the day displayed.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   *
+   * @returns {MozCalendarEventColumn} - The column.
+   */
+  getEventColumn(win) {
+    return this.#helper.getEventColumn(win, 1);
+  }
+
+  /**
+   * Provides the calendar-event-box elements for the day.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   *
+   * @returns {MozCalendarEventBox[]} - The event boxes.
+   */
+  getEventBoxes(win) {
+    return this.#helper.getEventBoxes(win, 1);
+  }
+
+  /**
+   * Provides the calendar-event-box at "index" located in the event column for
+   * the day displayed.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} index - Indicates which event box to select.
+   *
+   * @returns {MozCalendarEventBox|undefined} - The event box, if it exists.
+   */
+  getEventBoxAt(win, index) {
+    return this.#helper.getEventBoxAt(win, 1, index);
+  }
+
+  /**
+   * Provides the .multiday-hour-box element for the specified hour. This
+   * element can be double clicked to create a new event at that hour.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} hour - Must be between 0-23.
+   *
+   * @returns {XULElement} - The hour box.
+   */
+  getHourBoxAt(win, hour) {
+    return this.#helper.getHourBoxAt(win, 1, hour);
+  }
+
+  /**
+   * Provides the all-day header, which can be double clicked to create a new
+   * all-day event.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   *
+   * @returns {CalendarHeaderContainer} - The all-day header.
+   */
+  getAllDayHeader(win) {
+    return this.#helper.getAllDayHeader(win, 1);
+  }
+
+  /**
+   * Provides the all-day calendar-editable-item located at index for the
+   * current day.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} index - Indicates which item to select (1-based).
+   *
+   * @returns {MozCalendarEditableItem|undefined} - The all-day item, if it
+   *   exists.
+   */
+  getAllDayItemAt(win, index) {
+    return this.#helper.getAllDayItemAt(win, 1, index);
+  }
+
+  /**
+   * Waits for the calendar-event-box at "index", located in the event
+   * column for the day displayed to appear.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} index - Indicates which item to select (1-based).
+   *
+   * @returns {Promise<MozCalendarEventBox>} - The event box.
+   */
+  async waitForEventBoxAt(win, index) {
+    return this.#helper.waitForEventBoxAt(win, 1, index);
+  }
+
+  /**
+   * Waits for the calendar-event-box at "index", located in the event column
+   * for the current day to disappear.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} index - Indicates the event box (1-based).
+   */
+  async waitForNoEventBoxAt(win, index) {
+    return this.#helper.waitForNoEventBoxAt(win, 1, index);
+  }
+
+  /**
+   * Wait for the all-day calendar-editable-item for the day.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} index - Indicates which item to select (1-based).
+   *
+   * @returns {Promise<MozCalendarEditableItem>} - The all-day item.
+   */
+  async waitForAllDayItemAt(win, index) {
+    return this.#helper.waitForAllDayItemAt(win, 1, index);
+  }
+
+  /**
+   * Opens the event dialog for viewing for the event box located at the
+   * specified index.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} index - Indicates which event to select.
+   *
+   * @returns {Promise<Window>} - The summary event dialog window.
+   */
+  async viewEventAt(win, index) {
+    return this.#helper.viewEventAt(win, 1, index);
+  }
+
+  /**
+   * Opens the event dialog for editing for the event box located at the
+   * specified index.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} index - Indicates which event to select.
+   *
+   * @returns {Promise<EditItemAtResult>}
+   */
+  async editEventAt(win, index) {
+    return this.#helper.editEventAt(win, 1, index);
+  }
+
+  /**
+   * Opens the event dialog for editing for a single occurrence of the event
+   * box located at the specified index.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} index - Indicates which event box to select.
+   *
+   * @returns {Promise<EditItemAtResult>}
+   */
+  async editEventOccurrenceAt(win, index) {
+    return this.#helper.editEventOccurrenceAt(win, 1, index);
+  }
+
+  /**
+   * Opens the event dialog for editing all occurrences of the event box
+   * located at the specified index.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} index - Indicates which event box to select.
+   *
+   * @returns {Promise<EditItemAtResult>}
+   */
+  async editEventOccurrencesAt(win, index) {
+    return this.#helper.editEventOccurrencesAt(win, 1, index);
+  }
+}
+
+/**
+ * Helper class for testing the week view of the calendar.
+ */
+class CalendarWeekViewTestUtils {
+  constructor(rootSelector = "#week-view") {
+    this.rootSelector = rootSelector;
+  }
+
+  /**
+   * Provides the column container element for the day specified.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Must be between 1-7.
+   *
+   * @throws If the day parameter is out of range.
+   * @returns {HTMLElement} - The column container element.
+   */
+  getColumnContainer(win, day) {
+    if (day < 1 || day > 7) {
+      throw new Error(
+        `Invalid parameter to #getColumnContainer(): expected day=1-7, got day=${day}.`
+      );
+    }
+
+    let containers = win.document.documentElement.querySelectorAll(
+      `${this.rootSelector} .day-column-container`
+    );
+    return containers[day - 1];
+  }
+
+  /**
+   * Provides the element containing the formatted date for the day specified.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Must be between 1-7.
+   *
+   * @throws If the day parameter is out of range.
+   * @returns {HTMLElement} - The column heading container element.
+   */
+  getColumnHeading(win, day) {
+    let container = this.getColumnContainer(win, day);
+    return container.querySelector(".day-column-heading");
+  }
+
+  /**
+   * Provides the calendar-event-column for the day specified.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Must be between 1-7
+   *
+   * @throws - If the day parameter is out of range.
+   * @returns {MozCalendarEventColumn} - The column.
+   */
+  getEventColumn(win, day) {
+    let container = this.getColumnContainer(win, day);
+    return container.querySelector("calendar-event-column");
+  }
+
+  /**
+   * Provides the calendar-event-box elements for the day specified.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Must be between 1-7.
+   *
+   * @returns {MozCalendarEventBox[]} - The event boxes.
+   */
+  getEventBoxes(win, day) {
+    let container = this.getColumnContainer(win, day);
+    return container.querySelectorAll(".multiday-events-list calendar-event-box");
+  }
+
+  /**
+   * Provides the calendar-event-box at "index" located in the event column for
+   * the specified day.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates which event box to select.
+   *
+   * @returns {MozCalendarEventBox|undefined} - The event box, if it exists.
+   */
+  getEventBoxAt(win, day, index) {
+    return this.getEventBoxes(win, day)[index - 1];
+  }
+
+  /**
+   * Provides the .multiday-hour-box element for the specified hour. This
+   * element can be double clicked to create a new event at that hour.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Day of the week, between 1-7.
+   * @param {number} hour - Must be between 0-23.
+   *
+   * @throws If the day or hour are out of range.
+   * @returns {XULElement} - The hour box.
+   */
+  getHourBoxAt(win, day, hour) {
+    let container = this.getColumnContainer(win, day);
+    return container.querySelectorAll(".multiday-hour-box")[hour];
+  }
+
+  /**
+   * Provides the all-day header, which can be double clicked to create a new
+   * all-day event for the specified day.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Day of the week, between 1-7.
+   *
+   * @throws If the day is out of range.
+   * @returns {CalendarHeaderContainer} - The all-day header.
+   */
+  getAllDayHeader(win, day) {
+    let container = this.getColumnContainer(win, day);
+    return container.querySelector("calendar-header-container");
+  }
+
+  /**
+   * Provides the all-day calendar-editable-item located at "index" for the
+   * specified day.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Day of the week, between 1-7.
+   * @param {number} index - Indicates which item to select (starting from 1).
+   *
+   * @throws If the day or index are out of range.
+   * @returns {MozCalendarEditableItem|undefined} - The all-day item, if it
+   *   exists.
+   */
+  getAllDayItemAt(win, day, index) {
+    let allDayHeader = this.getAllDayHeader(win, day);
+    return allDayHeader.querySelectorAll("calendar-editable-item")[index - 1];
+  }
+
+  /**
+   * Waits for the calendar-event-box at "index", located in the event column
+   * for the day specified to appear.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Day of the week, between 1-7.
+   * @param {number} index - Indicates which event box to select.
+   *
+   * @returns {MozCalendarEventBox} - The event box.
+   */
+  async waitForEventBoxAt(win, day, index) {
+    return TestUtils.waitForCondition(
+      () => this.getEventBoxAt(win, day, index),
+      `calendar-event-box at day=${day}, index=${index} did not appear in time`
+    );
+  }
+
+  /**
+   * Waits until the calendar-event-box at "index", located in the event column
+   * for the day specified disappears.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Day of the week, between 1-7.
+   * @param {number} index - Indicates which event box to select.
+   */
+  async waitForNoEventBoxAt(win, day, index) {
+    await TestUtils.waitForCondition(
+      () => !this.getEventBoxAt(win, day, index),
+      `calendar-event-box at day=${day}, index=${index} still present`
+    );
+  }
+
+  /**
+   * Waits for the all-day calendar-editable-item at "index", located in the
+   * event column for the day specified to appear.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Day of the week, between 1-7.
+   * @param {number} index - Indicates which item to select (starting from 1).
+   *
+   * @returns {Promise<MozCalendarEditableItem>} - The all-day item.
+   */
+  async waitForAllDayItemAt(win, day, index) {
+    return TestUtils.waitForCondition(
+      () => this.getAllDayItemAt(win, day, index),
+      `All-day calendar-editable-item at day=${day}, index=${index} did not appear in time`
+    );
+  }
+
+  /**
+   * Opens the event dialog for viewing for the event box located at the
+   * specified parameters.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates which event to select.
+   *
+   * @returns {Promise<Window>} - The summary event dialog window.
+   */
+  async viewEventAt(win, day, index) {
+    let item = await this.waitForEventBoxAt(win, day, index);
+    return CalendarTestUtils.viewItem(win, item);
+  }
+
+  /**
+   * Opens the event dialog for editing for the event box located at the
+   * specified parameters.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates which event to select.
+   *
+   * @returns {Promise<EditItemAtResult>}
+   */
+  async editEventAt(win, day, index) {
+    let item = await this.waitForEventBoxAt(win, day, index);
+    return CalendarTestUtils.editItem(win, item);
+  }
+
+  /**
+   * Opens the event dialog for editing for a single occurrence of the event
+   * box located at the specified parameters.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates which event box to select.
+   *
+   * @returns {Promise<EditItemAtResult>}
+   */
+  async editEventOccurrenceAt(win, day, index) {
+    let item = await this.waitForEventBoxAt(win, day, index);
+    return CalendarTestUtils.editItemOccurrence(win, item);
+  }
+
+  /**
+   * Opens the event dialog for editing all occurrences of the event box
+   * located at the specified parameters.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates which event box to select.
+   *
+   * @returns {Promise<EditItemAtResult>}
+   */
+  async editEventOccurrencesAt(win, day, index) {
+    let item = await this.waitForEventBoxAt(win, day, index);
+    return CalendarTestUtils.editItemOccurrences(win, item);
+  }
+}
+
+/**
+ * Helper class for testing the multiweek and month views of the calendar.
+ */
+class CalendarMonthViewTestUtils {
+  /**
+   * @param {string} rootSelector
+   */
+  constructor(rootSelector) {
+    this.rootSelector = rootSelector;
+  }
+
+  /**
+   * Provides the calendar-month-day-box element located at the specified day,
+   * week combination.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} week - Must be between 1-6. The cap may be as low as 1
+   * depending on the user preference calendar.weeks.inview.
+   * @param {number} day - Must be between 1-7.
+   *
+   * @throws If the day or week parameters are out of range.
+   * @returns {MozCalendarMonthDayBox}
+   */
+  getDayBox(win, week, day) {
+    if (!(week >= 1 && week <= 6 && day >= 1 && day <= 7)) {
+      throw new Error(
+        `Invalid parameters to getDayBox(): ` +
+          `expected week=1-6, day=1-7, got week=${week}, day=${day},`
+      );
+    }
+
+    return win.document.documentElement.querySelector(
+      `${this.rootSelector} .monthbody > tr:nth-of-type(${week}) >
+        td:nth-of-type(${day}) > calendar-month-day-box`
+    );
+  }
+
+  /**
+   * Get the calendar-month-day-box-item located in the specified day box, at
+   * the target index.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} week - Must be between 1-6.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates which item to select.
+   *
+   * @throws If the index, day or week parameters are out of range.
+   * @returns {MozCalendarMonthDayBoxItem}
+   */
+  getItemAt(win, week, day, index) {
+    if (!(index >= 1)) {
+      throw new Error(`Invalid parameters to getItemAt(): expected index>=1, got index=${index}.`);
+    }
+
+    let dayBox = this.getDayBox(win, week, day);
+    return dayBox.querySelector(`li:nth-of-type(${index}) calendar-month-day-box-item`);
+  }
+
+  /**
+   * Waits for the calendar-month-day-box-item at "index", located in the
+   * specified week,day combination to appear.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} week - Must be between 1-6.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates which item to select.
+   *
+   * @returns {MozCalendarMonthDayBoxItem}
+   */
+  async waitForItemAt(win, week, day, index) {
+    return TestUtils.waitForCondition(
+      () => this.getItemAt(win, week, day, index),
+      `calendar-month-day-box-item at week=${week}, day=${day}, index=${index} did not appear in time`
+    );
+  }
+
+  /**
+   * Waits for the calendar-month-day-box-item at "index", located in the
+   * specified week,day combination to disappear.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} week - Must be between 1-6.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates the item that should no longer be present.
+   */
+  async waitForNoItemAt(win, week, day, index) {
+    await TestUtils.waitForCondition(
+      () => !this.getItemAt(win, week, day, index),
+      `calendar-month-day-box-item at week=${week}, day=${day}, index=${index} still present`
+    );
+  }
+
+  /**
+   * Opens the event dialog for viewing for the item located at the specified
+   * parameters.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} week - Must be between 1-6.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates which item to select.
+   *
+   * @returns {Window} - The summary event dialog window.
+   */
+  async viewItemAt(win, week, day, index) {
+    let item = await this.waitForItemAt(win, week, day, index);
+    return CalendarTestUtils.viewItem(win, item);
+  }
+
+  /**
+   * Opens the event dialog for editing for the item located at the specified
+   * parameters.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} week - Must be between 1-6.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates which item to select.
+   *
+   * @returns {EditItemAtResult}
+   */
+  async editItemAt(win, week, day, index) {
+    let item = await this.waitForItemAt(win, week, day, index);
+    return CalendarTestUtils.editItem(win, item);
+  }
+
+  /**
+   * Opens the event dialog for editing for a single occurrence of the item
+   * located at the specified parameters.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} week - Must be between 1-6.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates which item to select.
+   *
+   * @returns {EditItemAtResult}
+   */
+  async editItemOccurrenceAt(win, week, day, index) {
+    let item = await this.waitForItemAt(win, week, day, index);
+    return CalendarTestUtils.editItemOccurrence(win, item);
+  }
+
+  /**
+   * Opens the event dialog for editing all occurrences of the item
+   * located at the specified parameters.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} week - Must be between 1-6.
+   * @param {number} day - Must be between 1-7.
+   * @param {number} index - Indicates which item to select.
+   *
+   * @returns {EditItemAtResult}
+   */
+  async editItemOccurrencesAt(win, week, day, index) {
+    let item = await this.waitForItemAt(win, week, day, index);
+    return CalendarTestUtils.editItemOccurrences(win, item);
+  }
+}
+
+/**
+ * Non-mozmill calendar helper utility.
+ */
+const CalendarTestUtils = {
+  /**
+   * Helper methods for item editing.
+   */
+  items: {
+    cancelItemDialog,
+    saveAndCloseItemDialog,
+    setData,
+  },
+
+  /**
+   * Helpers specific to the day view.
+   */
+  dayView: new CalendarDayViewTestUtils(),
+
+  /**
+   * Helpers specific to the week view.
+   */
+  weekView: new CalendarWeekViewTestUtils(),
+
+  /**
+   * Helpers specific to the multiweek view.
+   */
+  multiweekView: new CalendarMonthViewTestUtils("#multiweek-view"),
+
+  /**
+   * Helpers specific to the month view.
+   */
+  monthView: new CalendarMonthViewTestUtils("#month-view"),
+
+  /**
+   * Dedent the template string tagged with this function to make indented data
+   * easier to read. Usage:
+   *
+   * let data = dedent`
+   *     This is indented data it will be unindented so that the first line has
+   *       no leading spaces and the second is indented by two spaces.
+   * `;
+   *
+   * @param strings       The string fragments from the template string
+   * @param ...values     The interpolated values
+   * @returns The interpolated, dedented string
+   */
+  dedent(strings, ...values) {
+    let parts = [];
+    // Perform variable interpolation
+    let minIndent = Infinity;
+    for (let [i, string] of strings.entries()) {
+      let innerparts = string.split("\n");
+      if (i == 0) {
+        innerparts.shift();
+      }
+      if (i == strings.length - 1) {
+        innerparts.pop();
+      }
+      for (let [j, ip] of innerparts.entries()) {
+        let match = ip.match(/^(\s*)\S*/);
+        if (j != 0) {
+          minIndent = Math.min(minIndent, match[1].length);
+        }
+      }
+      parts.push(innerparts);
+    }
+
+    return parts
+      .map((part, i) => {
+        return (
+          part
+            .map((line, j) => {
+              return j == 0 && i > 0 ? line : line.substr(minIndent);
+            })
+            .join("\n") + (i < values.length ? values[i] : "")
+        );
+      })
+      .join("");
+  },
+
+  /**
+   * Creates and registers a new calendar with the calendar manager. The
+   * created calendar will be set as the default calendar.
+   *
+   * @param {string} - name
+   * @param {string} - type
+   *
+   * @returns {calICalendar}
+   */
+  createCalendar(name = "Test", type = "storage") {
+    let calendar = cal.manager.createCalendar(type, Services.io.newURI(`moz-${type}-calendar://`));
+    calendar.name = name;
+    calendar.setProperty("calendar-main-default", true);
+    cal.manager.registerCalendar(calendar);
+    return calendar;
+  },
+
+  /**
+   * Convenience method for removing a calendar using its proxy.
+   *
+   * @param {calICalendar} calendar - A calendar to remove.
+   */
+  removeCalendar(calendar) {
+    cal.manager.unregisterCalendar(calendar);
+  },
+
+  /**
+   * Ensures the calendar tab is open
+   *
+   * @param {Window} win
+   */
+  async openCalendarTab(win) {
+    let tabmail = win.document.getElementById("tabmail");
+    let calendarMode = tabmail.tabModes.calendar;
+
+    if (calendarMode.tabs.length == 1) {
+      tabmail.selectedTab = calendarMode.tabs[0];
+    } else {
+      let calendarTabButton = win.document.getElementById("calendarButton");
+      EventUtils.synthesizeMouseAtCenter(calendarTabButton, { clickCount: 1 }, win);
+    }
+
+    Assert.equal(calendarMode.tabs.length, 1, "calendar tab is open");
+    Assert.equal(tabmail.selectedTab, calendarMode.tabs[0], "calendar tab is selected");
+
+    await new Promise(resolve => win.setTimeout(resolve));
+  },
+
+  /**
+   * Make sure the current view has finished loading.
+   *
+   * @param {Window} win
+   */
+  async ensureViewLoaded(win) {
+    await win.currentView().ready;
+  },
+
+  /**
+   * Ensures the calendar view is in the specified mode.
+   *
+   * @param {Window} win
+   * @param {string} viewName
+   */
+  async setCalendarView(win, viewName) {
+    await CalendarTestUtils.openCalendarTab(win);
+    await CalendarTestUtils.ensureViewLoaded(win);
+
+    let viewTabButton = win.document.querySelector(
+      `.calview-toggle-item[aria-controls="${viewName}-view"]`
+    );
+    EventUtils.synthesizeMouseAtCenter(viewTabButton, { clickCount: 1 }, win);
+    Assert.equal(win.currentView().id, `${viewName}-view`);
+
+    await CalendarTestUtils.ensureViewLoaded(win);
+  },
+
+  /**
+   * Step forward in the calendar view.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} n - Number of times to move the view forward.
+   */
+  async calendarViewForward(win, n) {
+    let viewForwardButton = win.document.getElementById("nextViewButton");
+    for (let i = 0; i < n; i++) {
+      await clickAndWait(win, viewForwardButton);
+      await CalendarTestUtils.ensureViewLoaded(win);
+    }
+  },
+
+  /**
+   * Step backward in the calendar view.
+   *
+   * @param {Window} win - The window the calendar is displayed in.
+   * @param {number} n - Number of times to move the view backward.
+   */
+  async calendarViewBackward(win, n) {
+    let viewBackwardButton = win.document.getElementById("previousViewButton");
+    for (let i = 0; i < n; i++) {
+      await clickAndWait(win, viewBackwardButton);
+      await CalendarTestUtils.ensureViewLoaded(win);
+    }
+  },
+
+  /**
+   * Ensures the calendar tab is not open.
+   *
+   * @param {Window} win
+   */
+  async closeCalendarTab(win) {
+    let tabmail = win.document.getElementById("tabmail");
+    let calendarMode = tabmail.tabModes.calendar;
+
+    if (calendarMode.tabs.length == 1) {
+      tabmail.closeTab(calendarMode.tabs[0]);
+    }
+
+    Assert.equal(calendarMode.tabs.length, 0, "calendar tab is not open");
+
+    await new Promise(resolve => win.setTimeout(resolve));
+  },
+
+  /**
+   * Opens the event dialog for viewing by clicking on the provided event item.
+   *
+   * @param {Window} win - The window containing the calendar.
+   * @param {MozCalendarEditableItem} item - An event box item that can be
+   * clicked on to open the dialog.
+   *
+   * @returns {Promise<Window>}
+   */
+  async viewItem(win, item) {
+    if (Services.focus.activeWindow != win) {
+      await BrowserTestUtils.waitForEvent(win, "focus");
+    }
+
+    let promise = this.waitForEventDialog("view");
+    EventUtils.synthesizeMouseAtCenter(item, { clickCount: 2 }, win);
+    return promise;
+  },
+
+  async _editNewItem(win, target, type) {
+    let dialogPromise = CalendarTestUtils.waitForEventDialog("edit");
+
+    if (target) {
+      this.scrollViewToTarget(target, true);
+      EventUtils.synthesizeMouse(target, 1, 1, { clickCount: 2 }, win);
+    } else {
+      let buttonId = `sidePanelNew${type[0].toUpperCase()}${type.slice(1).toLowerCase()}`;
+      EventUtils.synthesizeMouseAtCenter(win.document.getElementById(buttonId), {}, win);
+    }
+
+    let dialogWindow = await dialogPromise;
+    let iframe = dialogWindow.document.querySelector("#calendar-item-panel-iframe");
+    await new Promise(resolve => iframe.contentWindow.setTimeout(resolve));
+    Assert.report(false, undefined, undefined, `New ${type} dialog opened`);
+    return {
+      dialogWindow,
+      dialogDocument: dialogWindow.document,
+      iframeWindow: iframe.contentWindow,
+      iframeDocument: iframe.contentDocument,
+    };
+  },
+
+  /**
+   * Opens the dialog for editing a new event. An optional day/week view
+   * hour box or multiweek/month view calendar-month-day-box can be specified
+   * to simulate creation of the event at that target.
+   *
+   * @param {Window} win - The window containing the calendar.
+   * @param {XULElement?} target - The <spacer> or <calendar-month-day-box>
+   *                               to click on, if not specified, the new event
+   *                               button is used.
+   */
+  async editNewEvent(win, target) {
+    return this._editNewItem(win, target, "event");
+  },
+
+  /**
+   * Opens the dialog for editing a new task.
+   *
+   * @param {Promise<Window>} win - The window containing the task tree.
+   */
+  async editNewTask(win) {
+    return this._editNewItem(win, null, "task");
+  },
+
+  async _editItem(win, item, selector) {
+    let summaryWin = await this.viewItem(win, item);
+    let promise = this.waitForEventDialog("edit");
+    let button = summaryWin.document.querySelector(selector);
+    button.click();
+
+    let dialogWindow = await promise;
+    let iframe = dialogWindow.document.querySelector("#calendar-item-panel-iframe");
+    return {
+      dialogWindow,
+      dialogDocument: dialogWindow.document,
+      iframeWindow: iframe.contentWindow,
+      iframeDocument: iframe.contentDocument,
+    };
+  },
+
+  /**
+   * Opens the event dialog for editing by clicking on the provided event item.
+   *
+   * @param {Window} win - The window containing the calendar.
+   * @param {MozCalendarEditableItem} item - An event box item that can be
+   * clicked on to open the dialog.
+   *
+   * @returns {Promise<EditItemAtResult>}
+   */
+  async editItem(win, item) {
+    return this._editItem(win, item, "#calendar-summary-dialog-edit-button");
+  },
+
+  /**
+   * Opens the event dialog for editing a single occurrence of a repeating event
+   * by clicking on the provided event item.
+   *
+   * @param {Window} win - The window containing the calendar.
+   * @param {MozCalendarEditableItem} item - An event box item that can be
+   * clicked on to open the dialog.
+   *
+   * @returns {Window}
+   */
+  async editItemOccurrence(win, item) {
+    return this._editItem(win, item, "#edit-button-context-menu-this-occurrence");
+  },
+
+  /**
+   * Opens the event dialog for editing all occurrences of a repeating event
+   * by clicking on the provided event box.
+   *
+   * @param {Window} win - The window containing the calendar.
+   * @param {MozCalendarEditableItem} item - An event box item that can be
+   * clicked on to open the dialog.
+   *
+   * @returns {Window}
+   */
+  async editItemOccurrences(win, item) {
+    return this._editItem(win, item, "#edit-button-context-menu-all-occurrences");
+  },
+
+  /**
+   * This produces a Promise for waiting on an event dialog to open.
+   * The mode parameter can be specified to indicate which of the dialogs to
+   * wait for.
+   *
+   * @param {string} [mode="view"] Determines which dialog we are waiting on,
+   *  can be "view" for the summary or "edit" for the editing one.
+   *
+   * @returns {Promise<Window>}
+   */
+  waitForEventDialog(mode = "view") {
+    let uri =
+      mode === "edit"
+        ? "chrome://calendar/content/calendar-event-dialog.xhtml"
+        : "chrome://calendar/content/calendar-summary-dialog.xhtml";
+
+    return BrowserTestUtils.domWindowOpened(null, async win => {
+      await BrowserTestUtils.waitForEvent(win, "load");
+
+      if (win.document.documentURI != uri) {
+        return false;
+      }
+
+      Assert.report(false, undefined, undefined, "Event dialog opened");
+      await TestUtils.waitForCondition(
+        () => Services.focus.activeWindow == win,
+        "event dialog active"
+      );
+
+      if (mode === "edit") {
+        let iframe = win.document.getElementById("calendar-item-panel-iframe");
+        await TestUtils.waitForCondition(
+          () => iframe.contentWindow?.onLoad?.hasLoaded,
+          "waiting for iframe to be loaded"
+        );
+        await TestUtils.waitForCondition(
+          () => Services.focus.focusedWindow == iframe.contentWindow,
+          "waiting for iframe to be focused"
+        );
+      }
+      return true;
+    });
+  },
+
+  /**
+   * Go to a specific date using the minimonth.
+   *
+   * @param {Window} win - Main window
+   * @param {number} year - Four-digit year
+   * @param {number} month - 1-based index of a month
+   * @param {number} day - 1-based index of a day
+   */
+  async goToDate(win, year, month, day) {
+    let miniMonth = win.document.getElementById("calMinimonth");
+
+    let activeYear = miniMonth.querySelector(".minimonth-year-name").getAttribute("value");
+
+    let activeMonth = miniMonth.querySelector(".minimonth-month-name").getAttribute("monthIndex");
+
+    async function doScroll(name, difference, sleepTime) {
+      if (difference === 0) {
+        return;
+      }
+      let query = `.${name}s-${difference > 0 ? "back" : "forward"}-button`;
+      let scrollArrow = await TestUtils.waitForCondition(
+        () => miniMonth.querySelector(query),
+        `Query for scroll: ${query}`
+      );
+
+      for (let i = 0; i < Math.abs(difference); i++) {
+        EventUtils.synthesizeMouseAtCenter(scrollArrow, {}, win);
+        await new Promise(resolve => win.setTimeout(resolve, sleepTime));
+      }
+    }
+
+    await doScroll("year", activeYear - year, 10);
+    await doScroll("month", activeMonth - (month - 1), 25);
+
+    function getMiniMonthDay(week, day) {
+      return miniMonth.querySelector(
+        `.minimonth-cal-box > tr.minimonth-row-body:nth-of-type(${week + 1}) > ` +
+          `td.minimonth-day:nth-of-type(${day})`
+      );
+    }
+
+    let positionOfFirst = 7 - getMiniMonthDay(1, 7).textContent;
+    let weekDay = ((positionOfFirst + day - 1) % 7) + 1;
+    let week = Math.floor((positionOfFirst + day - 1) / 7) + 1;
+
+    // Pick day.
+    EventUtils.synthesizeMouseAtCenter(getMiniMonthDay(week, weekDay), {}, win);
+    await CalendarTestUtils.ensureViewLoaded(win);
+  },
+
+  /**
+   * Go to today.
+   *
+   * @param {Window} win - Main window
+   */
+  async goToToday(win) {
+    EventUtils.synthesizeMouseAtCenter(this.getNavBarTodayButton(win), {}, win);
+    await CalendarTestUtils.ensureViewLoaded(win);
+  },
+
+  /**
+   * Assert whether the given event box's edges are visually draggable (and
+   * hence, editable) at its edges or not.
+   *
+   * @param {MozCalendarEventBox} eventBox - The event box to test.
+   * @param {boolean} startDraggable - Whether we expect the start edge to be
+   *   draggable.
+   * @param {boolean} endDraggable - Whether we expect the end edge to be
+   *   draggable.
+   * @param {string} message - A message for assertions.
+   */
+  async assertEventBoxDraggable(eventBox, startDraggable, endDraggable, message) {
+    this.scrollViewToTarget(eventBox, true);
+    // Hover to see if the drag gripbars appear.
+    let enterPromise = BrowserTestUtils.waitForEvent(eventBox, "mouseenter");
+    // Hover over start.
+    EventUtils.synthesizeMouse(eventBox, 8, 8, { type: "mouseover" }, eventBox.ownerGlobal);
+    await enterPromise;
+    Assert.equal(
+      BrowserTestUtils.is_visible(eventBox.startGripbar),
+      startDraggable,
+      `Start gripbar should be ${startDraggable ? "visible" : "hidden"} on hover: ${message}`
+    );
+    Assert.equal(
+      BrowserTestUtils.is_visible(eventBox.endGripbar),
+      endDraggable,
+      `End gripbar should be ${endDraggable ? "visible" : "hidden"} on hover: ${message}`
+    );
+  },
+
+  /**
+   * Scroll the calendar view to show the given target.
+   *
+   * @param {Element} target - The target to scroll to. A descendent of a
+   *    calendar view.
+   * @param {boolean} alignStart - Whether to scroll the inline and block start
+   *   edges of the target into view, else scrolls the end edges into view.
+   */
+  scrollViewToTarget(target, alignStart) {
+    let multidayView = target.closest("calendar-day-view, calendar-week-view");
+    if (multidayView) {
+      // Multiday view has sticky headers, so scrollIntoView doesn't actually
+      // scroll far enough.
+      let scrollRect = multidayView.getScrollAreaRect();
+      let targetRect = target.getBoundingClientRect();
+      // We want to move the view by the difference between the starting/ending
+      // edge of the view and the starting/ending edge of the target.
+      let yDiff = alignStart
+        ? targetRect.top - scrollRect.top
+        : targetRect.bottom - scrollRect.bottom;
+      // In left-to-right, starting edge is the left edge. Otherwise, it is the
+      // right edge.
+      let xDiff =
+        alignStart == (target.ownerDocument.dir == "ltr")
+          ? targetRect.left - scrollRect.left
+          : targetRect.right - scrollRect.right;
+      multidayView.grid.scrollBy(xDiff, yDiff);
+    } else {
+      target.scrollIntoView(alignStart);
+    }
+  },
+
+  /**
+   * Save the current calendar views' UI states to be restored later.
+   *
+   * This is used with restoreCalendarViewsState to reset the view back to its
+   * initial loaded state after a test, so that later tests in the same group
+   * will receive the calendar view as if it was first opened after launching.
+   *
+   * @param {Window} win - The window that contains the calendar views.
+   *
+   * @returns {object} - An opaque object with data to pass to
+   *   restoreCalendarViewsState.
+   */
+  saveCalendarViewsState(win) {
+    return {
+      multidayViewsData: ["day", "week"].map(viewName => {
+        // Save the scroll state since test utilities may change the scroll
+        // position, and this is currently not reset on re-opening the tab.
+        let view = win.document.getElementById(`${viewName}-view`);
+        return { view, viewName, scrollMinute: view.scrollMinute };
+      }),
+    };
+  },
+
+  /**
+   * Clean up the calendar views after a test by restoring their UI to the saved
+   * state, and close the calendar tab.
+   *
+   * @param {Window} win - The window that contains the calendar views.
+   * @param {object} data - The data returned by saveCalendarViewsState.
+   */
+  async restoreCalendarViewsState(win, data) {
+    for (let { view, viewName, scrollMinute } of data.multidayViewsData) {
+      await this.setCalendarView(win, viewName);
+      // The scrollMinute is rounded to the nearest integer.
+      // As is the scroll pixels.
+      // When we scrollToMinute, the scroll position is rounded to the nearest
+      // integer, as is the subsequent scroll minute. So calling
+      //   scrollToMinute(min)
+      // will set
+      //   scrollMinute = round(round(min * P) / P)
+      // where P is the pixelsPerMinute of the view. Thus
+      //   scrollMinute = min +- round(0.5 / P)
+      let roundingError = Math.round(0.5 / view.pixelsPerMinute);
+      view.scrollToMinute(scrollMinute);
+      await TestUtils.waitForCondition(
+        () => Math.abs(view.scrollMinute - scrollMinute) <= roundingError,
+        "Waiting for scroll minute to restore"
+      );
+    }
+    await CalendarTestUtils.closeCalendarTab(win);
+  },
+
+  /**
+   * Get the Today button from the navigation bar.
+   *
+   * @param {Window} win - The window which contains the calendar.
+   *
+   * @returns {HTMLElement} - The today button.
+   */
+  getNavBarTodayButton(win) {
+    return win.document.getElementById("todayViewButton");
+  },
+
+  /**
+   * Get the label element containing a human-readable description of the
+   * displayed interval.
+   *
+   * @param {Window} win - The window which contains the calendar.
+   *
+   * @returns {HTMLLabelElement} - The interval description label.
+   */
+  getNavBarIntervalDescription(win) {
+    return win.document.getElementById("intervalDescription");
+  },
+
+  /**
+   * Get the label element containing an indication of which week or weeks are
+   * displayed.
+   *
+   * @param {Window} win - The window which contains the calendar.
+   *
+   * @returns {HTMLLabelElement} - The calendar week label.
+   */
+  getNavBarCalendarWeekBox(win) {
+    return win.document.getElementById("calendarWeek");
+  },
+};
diff --git a/comm/calendar/test/CalendarUtils.jsm b/comm/calendar/test/CalendarUtils.jsm
new file mode 100644
index 0000000000..708a65ad4e
--- /dev/null
+++ b/comm/calendar/test/CalendarUtils.jsm
@@ -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/. */
+
+const EXPORTED_SYMBOLS = [
+  "SHORT_SLEEP",
+  "MID_SLEEP",
+  "TIMEOUT_MODAL_DIALOG",
+  "handleDeleteOccurrencePrompt",
+  "execEventDialogCallback",
+  "checkMonthAlarmIcon",
+  "closeAllEventDialogs",
+];
+
+var { Assert } = ChromeUtils.importESModule("resource://testing-common/Assert.sys.mjs");
+var { BrowserTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/BrowserTestUtils.sys.mjs"
+);
+var EventUtils = ChromeUtils.import("resource://testing-common/mozmill/EventUtils.jsm");
+var { TestUtils } = ChromeUtils.importESModule("resource://testing-common/TestUtils.sys.mjs");
+
+const lazy = {};
+
+ChromeUtils.defineModuleGetter(
+  lazy,
+  "CalendarTestUtils",
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+var SHORT_SLEEP = 100;
+var MID_SLEEP = 500;
+var TIMEOUT_MODAL_DIALOG = 30000;
+var EVENT_DIALOG_NAME = "Calendar:EventDialog";
+
+/**
+ * Delete one or all occurrences using the prompt.
+ *
+ * @param {Window} window - Main window.
+ * @param {Element} element - Element which will open the dialog.
+ * @param {boolean} selectParent - true if all occurrences should be deleted.
+ */
+async function handleDeleteOccurrencePrompt(window, element, selectParent) {
+  let dialogPromise = BrowserTestUtils.promiseAlertDialog(
+    undefined,
+    "chrome://calendar/content/calendar-occurrence-prompt.xhtml",
+    {
+      callback(dialogWindow) {
+        let buttonId;
+        if (selectParent) {
+          buttonId = "accept-parent-button";
+        } else {
+          buttonId = "accept-occurrence-button";
+        }
+        let acceptButton = dialogWindow.document.getElementById(buttonId);
+        EventUtils.synthesizeMouseAtCenter(acceptButton, {}, dialogWindow);
+      },
+    }
+  );
+
+  EventUtils.synthesizeKey("VK_DELETE", {}, window);
+  await dialogPromise;
+}
+
+async function execEventDialogCallback(callback) {
+  let eventWindow = Services.wm.getMostRecentWindow(EVENT_DIALOG_NAME);
+
+  if (!eventWindow) {
+    eventWindow = await lazy.CalendarTestUtils.waitForEventDialog("edit");
+  }
+
+  let iframe = eventWindow.document.getElementById("calendar-item-panel-iframe");
+  await TestUtils.waitForCondition(() => iframe.contentWindow.onLoad?.hasLoaded);
+
+  await callback(eventWindow, iframe.contentWindow);
+}
+
+/**
+ * Checks if Alarm-Icon is shown on a given Event-Box.
+ *
+ * @param {Window} window - Main window.
+ * @param {number} week - Week to check between 1-6.
+ * @param {number} day - Day to check between 1-7.
+ */
+function checkMonthAlarmIcon(window, week, day) {
+  let dayBox = lazy.CalendarTestUtils.monthView.getItemAt(window, week, day, 1);
+  Assert.ok(dayBox.querySelector(".alarm-icons-box > .reminder-icon"));
+}
diff --git a/comm/calendar/test/ICSServer.jsm b/comm/calendar/test/ICSServer.jsm
new file mode 100644
index 0000000000..c0f120ec2a
--- /dev/null
+++ b/comm/calendar/test/ICSServer.jsm
@@ -0,0 +1,153 @@
+/* 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 EXPORTED_SYMBOLS = ["ICSServer"];
+
+const { Assert } = ChromeUtils.importESModule("resource://testing-common/Assert.sys.mjs");
+const { CommonUtils } = ChromeUtils.importESModule("resource://services-common/utils.sys.mjs");
+const { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
+
+var ICSServer = {
+  server: null,
+  isOpen: false,
+
+  ics: "",
+  etag: "",
+  open(username, password) {
+    this.server = new HttpServer();
+    this.server.start(-1);
+    this.isOpen = true;
+
+    this.username = username;
+    this.password = password;
+    this.server.registerPathHandler("/ping", this.ping);
+    this.server.registerPathHandler(this.path, this.handleICS.bind(this));
+
+    this.reset();
+  },
+
+  reset() {
+    this.ics = "";
+    this.etag = "";
+  },
+
+  close() {
+    if (!this.isOpen) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve =>
+      this.server.stop({
+        onStopped: () => {
+          this.isOpen = false;
+          resolve();
+        },
+      })
+    );
+  },
+
+  get origin() {
+    return `http://localhost:${this.server.identity.primaryPort}`;
+  },
+
+  get path() {
+    return "/test.ics";
+  },
+
+  get url() {
+    return `${this.origin}${this.path}`;
+  },
+
+  get altPath() {
+    return "/addressbooks/me/default/";
+  },
+
+  get altURL() {
+    return `${this.origin}${this.altPath}`;
+  },
+
+  checkAuth(request, response) {
+    if (!this.username || !this.password) {
+      return true;
+    }
+    if (!request.hasHeader("Authorization")) {
+      response.setStatusLine("1.1", 401, "Unauthorized");
+      response.setHeader("WWW-Authenticate", `Basic realm="test"`);
+      return false;
+    }
+
+    let value = request.getHeader("Authorization");
+    if (!value.startsWith("Basic ")) {
+      response.setStatusLine("1.1", 401, "Unauthorized");
+      response.setHeader("WWW-Authenticate", `Basic realm="test"`);
+      return false;
+    }
+
+    let [username, password] = atob(value.substring(6)).split(":");
+    if (username != this.username || password != this.password) {
+      response.setStatusLine("1.1", 401, "Unauthorized");
+      response.setHeader("WWW-Authenticate", `Basic realm="test"`);
+      return false;
+    }
+
+    return true;
+  },
+
+  ping(request, response) {
+    response.setStatusLine("1.1", 200, "OK");
+    response.setHeader("Content-Type", "text/plain");
+    response.write("pong");
+  },
+
+  handleICS(request, response) {
+    if (!this.checkAuth(request, response)) {
+      return;
+    }
+
+    switch (request.method) {
+      case "HEAD":
+        this.headICS(request, response);
+        return;
+      case "GET":
+        this.getICS(request, response);
+        return;
+      case "PUT":
+        this.putICS(request, response);
+        return;
+    }
+
+    Assert.report(true, undefined, undefined, "Should not have reached here");
+    response.setStatusLine("1.1", 405, "Method Not Allowed");
+    response.setHeader("Content-Type", "text/plain");
+    response.write(`Method not allowed: ${request.method}`);
+  },
+
+  headICS(request, response) {
+    response.setStatusLine("1.1", 200, "OK");
+    response.setHeader("Content-Type", "text/calendar");
+    response.setHeader("ETag", this.etag);
+  },
+
+  getICS(request, response) {
+    this.headICS(request, response);
+    response.write(this.ics);
+  },
+
+  async putICS(request, response) {
+    response.processAsync();
+
+    await this.putICSInternal(CommonUtils.readBytesFromInputStream(request.bodyInputStream));
+
+    response.setStatusLine("1.1", 204, "No Content");
+    response.setHeader("ETag", this.etag);
+
+    response.finish();
+  },
+
+  async putICSInternal(ics) {
+    this.ics = ics;
+
+    let hash = await crypto.subtle.digest("sha-1", new TextEncoder().encode(this.ics));
+    this.etag = Array.from(new Uint8Array(hash), c => c.toString(16).padStart(2, "0")).join("");
+  },
+};
diff --git a/comm/calendar/test/ItemEditingHelpers.jsm b/comm/calendar/test/ItemEditingHelpers.jsm
new file mode 100644
index 0000000000..812f5008cb
--- /dev/null
+++ b/comm/calendar/test/ItemEditingHelpers.jsm
@@ -0,0 +1,681 @@
+/* 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 EXPORTED_SYMBOLS = [
+  "cancelItemDialog",
+  "formatDate",
+  "formatTime",
+  "menulistSelect",
+  "saveAndCloseItemDialog",
+  "setData",
+];
+
+var { Assert } = ChromeUtils.importESModule("resource://testing-common/Assert.sys.mjs");
+var { TestUtils } = ChromeUtils.importESModule("resource://testing-common/TestUtils.sys.mjs");
+var { BrowserTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/BrowserTestUtils.sys.mjs"
+);
+var { sendString, synthesizeKey, synthesizeMouseAtCenter } = ChromeUtils.import(
+  "resource://testing-common/mozmill/EventUtils.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { CalDateTime } = ChromeUtils.import("resource:///modules/CalDateTime.jsm");
+var { setTimeout } = ChromeUtils.importESModule("resource://gre/modules/Timer.sys.mjs");
+
+function sleep(window, time = 0) {
+  return new Promise(resolve => window.setTimeout(resolve, time));
+}
+
+var dateFormatter = new Services.intl.DateTimeFormat(undefined, { dateStyle: "short" });
+var dateTimeFormatter = new Services.intl.DateTimeFormat(undefined, {
+  dateStyle: "short",
+  timeZone: "UTC",
+});
+var timeFormatter = new Services.intl.DateTimeFormat(undefined, {
+  timeStyle: "short",
+  timeZone: "UTC",
+});
+
+/**
+ * Formats a date for input in a datepicker. Don't use cal.dtz.formatter methods
+ * for this as they use the application locale but datepicker uses the OS locale.
+ *
+ * @param {calIDateTime} date
+ * @returns {string}
+ */
+function formatDate(date) {
+  if (date.isDate) {
+    return dateFormatter.format(cal.dtz.dateTimeToJsDate(date));
+  }
+
+  return dateTimeFormatter.format(cal.dtz.dateTimeToJsDate(date));
+}
+
+/**
+ * Formats a time for input in a timepicker. Don't use cal.dtz.formatter methods
+ * for this as they use the application locale but timepicker uses the OS locale.
+ *
+ * @param {calIDateTime} time
+ * @returns {string}
+ */
+function formatTime(time) {
+  return timeFormatter.format(cal.dtz.dateTimeToJsDate(time));
+}
+
+/**
+ * @callback dialogCallback
+ * @param {Window} - The calendar-event-dialog-recurrence.xhtml dialog.
+ */
+
+/**
+ * Helper function to enter event/task dialog data.
+ *
+ * @param {Window} dialogWindow - Item dialog outer window.
+ * @param {Window} iframeWindow - Item dialog inner iframe.
+ * @param {object} data
+ * @param {string} data.title - Item title.
+ * @param {string} data.location - Item location.
+ * @param {string} data.description - Item description.
+ * @param {string[]} data.categories - Category names to set - leave empty to clear.
+ * @param {string} data.calendar - ID of the calendar the item should be in.
+ * @param {boolean} data.allday
+ * @param {calIDateTime} data.startdate
+ * @param {calIDateTime} data.starttime
+ * @param {calIDateTime} data.enddate
+ * @param {calIDateTime} data.endtime
+ * @param {boolean} data.timezonedisplay - false for hidden, true for shown.
+ * @param {string} data.timezone - String identifying the timezone.
+ * @param {string|dialogCallback} data.repeat - Recurrence value, one of
+ *     none/daily/weekly/every.weekday/bi.weekly/monthly/yearly or a callback function to set a
+ *     custom value.
+ * @param {calIDateTime} data.repeatuntil
+ * @param {string} data.reminder -
+ *     none/0minutes/5minutes/15minutes/30minutes/1hour/2hours/12hours/1day/2days/1week
+ *     (Custom is not supported.)
+ * @param {string} data.priority - none/low/normal/high
+ * @param {string} data.privacy - public/confidential/private
+ * @param {string} data.status - none/tentative/confirmed/canceled for events
+ *     none/needs-action/in-process/completed/cancelled for tasks
+ * @param {calIDateTime} data.completed - Completion date (tasks only)
+ * @param {string} data.percent - Percentage complete (tasks only)
+ * @param {string} data.freebusy - free/busy
+ * @param {string} data.attachment.add - URL to add
+ * @param {string} data.attachment.remove - Label of url to remove. (without http://)
+ * @param {string} data.attendees.add - Email of attendees to add, comma separated.
+ * @param {string} data.attendees.remove - Email of attendees to remove, comma separated.
+ */
+async function setData(dialogWindow, iframeWindow, data) {
+  function replaceText(input, text) {
+    synthesizeMouseAtCenter(input, {}, iframeWindow);
+    synthesizeKey("a", { accelKey: true }, iframeWindow);
+    sendString(text, iframeWindow);
+  }
+
+  let dialogDocument = dialogWindow.document;
+  let iframeDocument = iframeWindow.document;
+
+  let isEvent = iframeWindow.calendarItem.isEvent();
+  let startPicker = iframeDocument.getElementById(isEvent ? "event-starttime" : "todo-entrydate");
+  let endPicker = iframeDocument.getElementById(isEvent ? "event-endtime" : "todo-duedate");
+
+  let startdateInput = startPicker._datepicker._inputField;
+  let enddateInput = endPicker._datepicker._inputField;
+  let starttimeInput = startPicker._timepicker._inputField;
+  let endtimeInput = endPicker._timepicker._inputField;
+  let completeddateInput = iframeDocument.getElementById("completed-date-picker")._inputField;
+  let untilDateInput = iframeDocument.getElementById("repeat-until-datepicker")._inputField;
+
+  // Wait for input elements' values to be populated.
+  await sleep(iframeWindow, 500);
+
+  // title
+  if (data.title !== undefined) {
+    let titleInput = iframeDocument.getElementById("item-title");
+    replaceText(titleInput, data.title);
+  }
+
+  // location
+  if (data.location !== undefined) {
+    let locationInput = iframeDocument.getElementById("item-location");
+    replaceText(locationInput, data.location);
+  }
+
+  // categories
+  if (data.categories !== undefined) {
+    await setCategories(iframeWindow, data.categories);
+    await sleep(iframeWindow);
+  }
+
+  // calendar
+  if (data.calendar !== undefined) {
+    await menulistSelect(iframeDocument.getElementById("item-calendar"), data.calendar);
+    await sleep(iframeWindow);
+  }
+
+  // all-day
+  if (data.allday !== undefined && isEvent) {
+    let checkbox = iframeDocument.getElementById("event-all-day");
+    if (checkbox.checked != data.allday) {
+      synthesizeMouseAtCenter(checkbox, {}, iframeWindow);
+    }
+  }
+
+  // timezonedisplay
+  if (data.timezonedisplay !== undefined) {
+    let menuitem = dialogDocument.getElementById("options-timezones-menuitem");
+    if (menuitem.getAttribute("checked") != data.timezonedisplay) {
+      synthesizeMouseAtCenter(menuitem, {}, iframeWindow);
+    }
+  }
+
+  // timezone
+  if (data.timezone !== undefined) {
+    await setTimezone(dialogWindow, iframeWindow, data.timezone);
+  }
+
+  // startdate
+  if (
+    data.startdate !== undefined &&
+    (data.startdate instanceof CalDateTime || data.startdate instanceof Ci.calIDateTime)
+  ) {
+    let startdate = formatDate(data.startdate);
+
+    if (!isEvent) {
+      let checkbox = iframeDocument.getElementById("todo-has-entrydate");
+      if (!checkbox.checked) {
+        synthesizeMouseAtCenter(checkbox, {}, iframeWindow);
+      }
+    }
+    replaceText(startdateInput, startdate);
+  }
+
+  // starttime
+  if (
+    data.starttime !== undefined &&
+    (data.starttime instanceof CalDateTime || data.starttime instanceof Ci.calIDateTime)
+  ) {
+    let starttime = formatTime(data.starttime);
+    replaceText(starttimeInput, starttime);
+    await sleep(iframeWindow);
+  }
+
+  // enddate
+  if (
+    data.enddate !== undefined &&
+    (data.enddate instanceof CalDateTime || data.enddate instanceof Ci.calIDateTime)
+  ) {
+    let enddate = formatDate(data.enddate);
+    if (!isEvent) {
+      let checkbox = iframeDocument.getElementById("todo-has-duedate");
+      if (!checkbox.checked) {
+        synthesizeMouseAtCenter(checkbox, {}, iframeWindow);
+      }
+    }
+    replaceText(enddateInput, enddate);
+  }
+
+  // endtime
+  if (
+    data.endtime !== undefined &&
+    (data.endtime instanceof CalDateTime || data.endtime instanceof Ci.calIDateTime)
+  ) {
+    let endtime = formatTime(data.endtime);
+    replaceText(endtimeInput, endtime);
+  }
+
+  // recurrence
+  if (data.repeat !== undefined) {
+    if (typeof data.repeat == "function") {
+      let repeatWindowPromise = BrowserTestUtils.promiseAlertDialog(
+        undefined,
+        "chrome://calendar/content/calendar-event-dialog-recurrence.xhtml",
+        {
+          async callback(recurrenceWindow) {
+            Assert.report(false, undefined, undefined, "Recurrence dialog opened");
+            await TestUtils.waitForCondition(
+              () => Services.focus.activeWindow == recurrenceWindow,
+              "recurrence dialog active"
+            );
+
+            await new Promise(resolve => recurrenceWindow.setTimeout(resolve, 500));
+            await data.repeat(recurrenceWindow);
+          },
+        }
+      );
+      await Promise.all([
+        menulistSelect(iframeDocument.getElementById("item-repeat"), "custom"),
+        repeatWindowPromise,
+      ]);
+      Assert.report(false, undefined, undefined, "Recurrence dialog closed");
+    } else {
+      await menulistSelect(iframeDocument.getElementById("item-repeat"), data.repeat);
+    }
+  }
+  if (
+    data.repeatuntil !== undefined &&
+    (data.repeatuntil instanceof CalDateTime || data.repeatuntil instanceof Ci.calIDateTime)
+  ) {
+    // Only fill in date, when the Datepicker is visible.
+    if (!iframeDocument.getElementById("repeat-untilDate").hidden) {
+      let untildate = formatDate(data.repeatuntil);
+      replaceText(untilDateInput, untildate);
+    }
+  }
+
+  // reminder
+  if (data.reminder !== undefined) {
+    await setReminderMenulist(iframeWindow, data.reminder);
+  }
+
+  // priority
+  if (data.priority !== undefined) {
+    dialogDocument.getElementById(`options-priority-${data.priority}-label`).click();
+  }
+
+  // privacy
+  if (data.privacy !== undefined) {
+    let button = dialogDocument.getElementById("button-privacy");
+    let shownPromise = BrowserTestUtils.waitForEvent(button, "popupshown");
+    synthesizeMouseAtCenter(button, {}, dialogWindow);
+    await shownPromise;
+    let hiddenPromise = BrowserTestUtils.waitForEvent(button, "popuphidden");
+    synthesizeMouseAtCenter(
+      dialogDocument.getElementById(`event-privacy-${data.privacy}-menuitem`),
+      {},
+      dialogWindow
+    );
+    await hiddenPromise;
+    await sleep(iframeWindow);
+  }
+
+  // status
+  if (data.status !== undefined) {
+    if (isEvent) {
+      dialogDocument.getElementById(`options-status-${data.status}-menuitem`).click();
+    } else {
+      await menulistSelect(iframeDocument.getElementById("todo-status"), data.status.toUpperCase());
+    }
+  }
+
+  let currentStatus = iframeDocument.getElementById("todo-status").value;
+
+  // completed on
+  if (
+    data.completed !== undefined &&
+    (data.completed instanceof CalDateTime || data.completed instanceof Ci.calIDateTime) &&
+    !isEvent
+  ) {
+    let completeddate = formatDate(data.completed);
+    if (currentStatus == "COMPLETED") {
+      replaceText(completeddateInput, completeddate);
+    }
+  }
+
+  // percent complete
+  if (
+    data.percent !== undefined &&
+    (currentStatus == "NEEDS-ACTION" ||
+      currentStatus == "IN-PROCESS" ||
+      currentStatus == "COMPLETED")
+  ) {
+    let percentCompleteInput = iframeDocument.getElementById("percent-complete-textbox");
+    replaceText(percentCompleteInput, data.percent);
+  }
+
+  // free/busy
+  if (data.freebusy !== undefined) {
+    dialogDocument.getElementById(`options-freebusy-${data.freebusy}-menuitem`).click();
+  }
+
+  // description
+  if (data.description !== undefined) {
+    synthesizeMouseAtCenter(
+      iframeDocument.getElementById("event-grid-tab-description"),
+      {},
+      iframeWindow
+    );
+    let descField = iframeDocument.getElementById("item-description");
+    replaceText(descField, data.description);
+  }
+
+  // attachment
+  if (data.attachment !== undefined) {
+    if (data.attachment.add !== undefined) {
+      await handleAddingAttachment(dialogWindow, data.attachment.add);
+    }
+    if (data.attachment.remove !== undefined) {
+      synthesizeMouseAtCenter(
+        iframeDocument.getElementById("event-grid-tab-attachments"),
+        {},
+        iframeWindow
+      );
+      let attachmentBox = iframeDocument.getElementById("attachment-link");
+      let attachments = attachmentBox.children;
+      for (let attachment of attachments) {
+        if (attachment.tooltipText.includes(data.attachment.remove)) {
+          synthesizeMouseAtCenter(attachment, {}, iframeWindow);
+          synthesizeKey("VK_DELETE", {}, dialogWindow);
+        }
+      }
+    }
+  }
+
+  // attendees
+  if (data.attendees !== undefined) {
+    // Display attendees Tab.
+    synthesizeMouseAtCenter(
+      iframeDocument.getElementById("event-grid-tab-attendees"),
+      {},
+      iframeWindow
+    );
+    // Make sure no notifications are sent, since handling this dialog is
+    // not working when deleting a parent of a recurring event.
+    let attendeeCheckbox = iframeDocument.getElementById("notify-attendees-checkbox");
+    if (!attendeeCheckbox.disabled && attendeeCheckbox.checked) {
+      synthesizeMouseAtCenter(attendeeCheckbox, {}, iframeWindow);
+    }
+
+    // add
+    if (data.attendees.add !== undefined) {
+      await addAttendees(dialogWindow, iframeWindow, data.attendees.add);
+    }
+    // delete
+    if (data.attendees.remove !== undefined) {
+      await deleteAttendees(iframeWindow, data.attendees.remove);
+    }
+  }
+
+  await sleep(iframeWindow);
+}
+
+/**
+ * Closes an event dialog window, saving the event.
+ *
+ * @param {Window} dialogWindow
+ */
+async function saveAndCloseItemDialog(dialogWindow) {
+  let dialogClosing = BrowserTestUtils.domWindowClosed(dialogWindow);
+  synthesizeMouseAtCenter(
+    dialogWindow.document.getElementById("button-saveandclose"),
+    {},
+    dialogWindow
+  );
+  await dialogClosing;
+  Assert.report(false, undefined, undefined, "Item dialog closed");
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+/**
+ * Closes an event dialog window, discarding any changes.
+ *
+ * @param {Window} dialogWindow
+ */
+function cancelItemDialog(dialogWindow) {
+  synthesizeKey("VK_ESCAPE", {}, dialogWindow);
+}
+
+/**
+ * Select an item in the reminder menulist.
+ * Custom reminders are not supported.
+ *
+ * @param {Window} iframeWindow - The event dialog iframe.
+ * @param {string} id - Identifying string of menuitem id.
+ */
+async function setReminderMenulist(iframeWindow, id) {
+  let iframeDocument = iframeWindow.document;
+  let menulist = iframeDocument.querySelector(".item-alarm");
+  let menuitem = iframeDocument.getElementById(`reminder-${id}-menuitem`);
+
+  Assert.ok(menulist, `<menulist id=${menulist.id}> exists`);
+  Assert.ok(menuitem, `<menuitem id=${id}> exists`);
+
+  menulist.focus();
+
+  synthesizeMouseAtCenter(menulist, {}, iframeWindow);
+  await BrowserTestUtils.waitForEvent(menulist, "popupshown");
+  synthesizeMouseAtCenter(menuitem, {}, iframeWindow);
+  await BrowserTestUtils.waitForEvent(menulist, "popuphidden");
+  await sleep(iframeWindow);
+}
+
+/**
+ * Set the categories in the event-dialog menulist-panel.
+ *
+ * @param {Window} iframeWindow - The event dialog iframe.
+ * @param {string[]} categories - Category names to set - leave empty to clear.
+ */
+async function setCategories(iframeWindow, categories) {
+  let iframeDocument = iframeWindow.document;
+  let menulist = iframeDocument.getElementById("item-categories");
+  let menupopup = iframeDocument.getElementById("item-categories-popup");
+
+  synthesizeMouseAtCenter(menulist, {}, iframeWindow);
+  await BrowserTestUtils.waitForEvent(menupopup, "popupshown");
+
+  // Iterate over categories and check if needed.
+  for (let item of menupopup.children) {
+    if (categories.includes(item.label)) {
+      item.setAttribute("checked", "true");
+    } else {
+      item.removeAttribute("checked");
+    }
+  }
+
+  let hiddenPromise = BrowserTestUtils.waitForEvent(menupopup, "popuphidden");
+  menupopup.hidePopup();
+  await hiddenPromise;
+}
+
+/**
+ * Add an URL attachment.
+ *
+ * @param {Window} dialogWindow - The event dialog.
+ * @param {string} url - URL to be added.
+ */
+async function handleAddingAttachment(dialogWindow, url) {
+  let dialogDocument = dialogWindow.document;
+  let attachButton = dialogDocument.querySelector("#button-url");
+  let menu = dialogDocument.querySelector("#button-attach-menupopup");
+  let menuShowing = BrowserTestUtils.waitForEvent(menu, "popupshown");
+  synthesizeMouseAtCenter(attachButton, {}, dialogWindow);
+  await menuShowing;
+
+  let dialogPromise = BrowserTestUtils.promiseAlertDialog(undefined, undefined, {
+    async callback(attachmentWindow) {
+      Assert.report(false, undefined, undefined, "Attachment dialog opened");
+      await TestUtils.waitForCondition(
+        () => Services.focus.activeWindow == attachmentWindow,
+        "attachment dialog active"
+      );
+
+      let attachmentDocument = attachmentWindow.document;
+      attachmentDocument.getElementById("loginTextbox").value = url;
+      attachmentDocument.querySelector("dialog").getButton("accept").click();
+    },
+  });
+  synthesizeMouseAtCenter(dialogDocument.querySelector("#button-attach-url"), {}, dialogWindow);
+  await dialogPromise;
+  Assert.report(false, undefined, undefined, "Attachment dialog closed");
+  await sleep(dialogWindow);
+}
+
+/**
+ * Add attendees to the event.
+ *
+ * @param {Window} dialogWindow - The event dialog.
+ * @param {Window} iframeWindow - The event dialog iframe.
+ * @param {string} attendeesString - Comma separated list of email-addresses to add.
+ */
+async function addAttendees(dialogWindow, iframeWindow, attendeesString) {
+  let dialogDocument = dialogWindow.document;
+
+  let attendees = attendeesString.split(",");
+  for (let attendee of attendees) {
+    let calAttendee = iframeWindow.attendees.find(aAtt => aAtt.id == `mailto:${attendee}`);
+    // Only add if not already present.
+    if (!calAttendee) {
+      let dialogPromise = BrowserTestUtils.promiseAlertDialog(
+        undefined,
+        "chrome://calendar/content/calendar-event-dialog-attendees.xhtml",
+        {
+          async callback(attendeesWindow) {
+            Assert.report(false, undefined, undefined, "Attendees dialog opened");
+            await TestUtils.waitForCondition(
+              () => Services.focus.activeWindow == attendeesWindow,
+              "attendees dialog active"
+            );
+
+            let attendeesDocument = attendeesWindow.document;
+            Assert.equal(attendeesDocument.activeElement.localName, "input");
+            Assert.equal(
+              attendeesDocument.activeElement.value,
+              "",
+              "active input value should be empty"
+            );
+            sendString(attendee, attendeesWindow);
+            Assert.report(false, undefined, undefined, `Sent attendee ${attendee}`);
+            // Windows needs the focus() call here.
+            attendeesDocument.querySelector("dialog").getButton("accept").focus();
+            synthesizeMouseAtCenter(
+              attendeesDocument.querySelector("dialog").getButton("accept"),
+              {},
+              attendeesWindow
+            );
+          },
+        }
+      );
+      synthesizeMouseAtCenter(dialogDocument.getElementById("button-attendees"), {}, dialogWindow);
+      await dialogPromise;
+      Assert.report(false, undefined, undefined, "Attendees dialog closed");
+      await sleep(iframeWindow);
+    }
+  }
+}
+
+/**
+ * Delete attendees from the event.
+ *
+ * @param {Window} iframeWindow - The event dialog iframe.
+ * @param {string} attendeesString - Comma separated list of email-addresses to delete.
+ */
+async function deleteAttendees(iframeWindow, attendeesString) {
+  let iframeDocument = iframeWindow.document;
+  let menupopup = iframeDocument.getElementById("attendee-popup");
+
+  // Now delete the attendees.
+  let attendees = attendeesString.split(",");
+  for (let attendee of attendees) {
+    let attendeeToDelete = iframeDocument.querySelector(
+      `.attendee-list [attendeeid="mailto:${attendee}"]`
+    );
+    if (attendeeToDelete) {
+      attendeeToDelete.focus();
+      synthesizeMouseAtCenter(attendeeToDelete, { type: "contextmenu" }, iframeWindow);
+      await BrowserTestUtils.waitForEvent(menupopup, "popupshown");
+      menupopup.activateItem(
+        iframeDocument.getElementById("attendee-popup-removeattendee-menuitem")
+      );
+      await BrowserTestUtils.waitForEvent(menupopup, "popuphidden");
+    }
+  }
+  await sleep(iframeWindow);
+}
+
+/**
+ * Set the timezone for the item
+ *
+ * @param {Window} dialogWindow - The event dialog.
+ * @param {Window} iframeWindow - The event dialog iframe.
+ * @param {string} timezone - String identifying the timezone.
+ */
+async function setTimezone(dialogWindow, iframeWindow, timezone) {
+  let dialogDocument = dialogWindow.document;
+  let iframeDocument = iframeWindow.document;
+
+  let menuitem = dialogDocument.getElementById("options-timezones-menuitem");
+  let label = iframeDocument.getElementById("timezone-starttime");
+  let menupopup = iframeDocument.getElementById("timezone-popup");
+  let customMenuitem = iframeDocument.getElementById("timezone-custom-menuitem");
+
+  if (!BrowserTestUtils.is_visible(label)) {
+    menuitem.click();
+    await TestUtils.waitForCondition(
+      () => BrowserTestUtils.is_visible(label),
+      "Timezone label should become visible"
+    );
+  }
+
+  await TestUtils.waitForCondition(() => !label.disabled, "Tiemzone label should become enabled");
+
+  let shownPromise = BrowserTestUtils.waitForEvent(menupopup, "popupshown");
+  let dialogPromise = BrowserTestUtils.promiseAlertDialog(
+    undefined,
+    "chrome://calendar/content/calendar-event-dialog-timezone.xhtml",
+    {
+      async callback(timezoneWindow) {
+        Assert.report(false, undefined, undefined, "Timezone dialog opened");
+        await TestUtils.waitForCondition(
+          () => Services.focus.activeWindow == timezoneWindow,
+          "timezone dialog active"
+        );
+
+        let timezoneDocument = timezoneWindow.document;
+        let timezoneMenulist = timezoneDocument.getElementById("timezone-menulist");
+        let timezoneMenuitem = timezoneMenulist.querySelector(`[value="${timezone}"]`);
+
+        let popupshown = BrowserTestUtils.waitForEvent(timezoneMenulist, "popupshown");
+        synthesizeMouseAtCenter(timezoneMenulist, {}, timezoneWindow);
+        await popupshown;
+
+        timezoneMenuitem.scrollIntoView();
+
+        let popuphidden = BrowserTestUtils.waitForEvent(timezoneMenulist, "popuphidden");
+        synthesizeMouseAtCenter(timezoneMenuitem, {}, timezoneWindow);
+        await popuphidden;
+
+        synthesizeMouseAtCenter(
+          timezoneDocument.querySelector("dialog").getButton("accept"),
+          {},
+          timezoneWindow
+        );
+      },
+    }
+  );
+
+  synthesizeMouseAtCenter(label, {}, iframeWindow);
+  await shownPromise;
+
+  synthesizeMouseAtCenter(customMenuitem, {}, iframeWindow);
+  await dialogPromise;
+  Assert.report(false, undefined, undefined, "Timezone dialog closed");
+
+  await new Promise(resolve => iframeWindow.setTimeout(resolve, 500));
+}
+
+/**
+ * Selects an item from a menulist.
+ *
+ * @param {Element} menulist
+ * @param {string} value
+ */
+async function menulistSelect(menulist, value) {
+  let win = menulist.ownerGlobal;
+  Assert.ok(menulist, `<menulist id=${menulist.id}> exists`);
+  let menuitem = menulist.querySelector(`menupopup > menuitem[value='${value}']`);
+  Assert.ok(menuitem, `<menuitem value=${value}> exists`);
+
+  menulist.focus();
+
+  let shownPromise = BrowserTestUtils.waitForEvent(menulist, "popupshown");
+  synthesizeMouseAtCenter(menulist, {}, win);
+  await shownPromise;
+
+  let hiddenPromise = BrowserTestUtils.waitForEvent(menulist, "popuphidden");
+  synthesizeMouseAtCenter(menuitem, {}, win);
+  await hiddenPromise;
+
+  await new Promise(resolve => win.setTimeout(resolve));
+  Assert.equal(menulist.value, value);
+}
diff --git a/comm/calendar/test/browser/browser.ini b/comm/calendar/test/browser/browser.ini
new file mode 100644
index 0000000000..5eb780310b
--- /dev/null
+++ b/comm/calendar/test/browser/browser.ini
@@ -0,0 +1,39 @@
+[default]
+head = head.js
+prefs =
+  calendar.debug.log=true
+  calendar.item.promptDelete=false
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+  calendar.week.start=0
+  mail.provider.suppress_dialog_on_startup=true
+  mail.spotlight.firstRunDone=true
+  mail.winsearch.firstRunDone=true
+  mailnews.oauth.loglevel=Debug
+  mailnews.start_page.override_url=about:blank
+  mailnews.start_page.url=about:blank
+  signon.rememberSignons=true
+subsuite = thunderbird
+support-files = data/**
+
+[browser_basicFunctionality.js]
+[browser_calDAV_discovery.js]
+[browser_calDAV_oAuth.js]
+tags = oauth
+[browser_calendarList.js]
+[browser_calendarTelemetry.js]
+[browser_calendarUnifinder.js]
+[browser_dragEventItem.js]
+[browser_eventDisplay_dayView.js]
+[browser_eventDisplay_multiWeekView.js]
+[browser_eventDisplay_weekView.js]
+[browser_eventUndoRedo.js]
+[browser_import.js]
+[browser_localICS.js]
+[browser_taskDelete.js]
+[browser_taskUndoRedo.js]
+[browser_tabs.js]
+[browser_taskDisplay.js]
+[browser_todayPane.js]
+[browser_todayPane_dragAndDrop.js]
+[browser_todayPane_visibility.js]
diff --git a/comm/calendar/test/browser/browser_basicFunctionality.js b/comm/calendar/test/browser/browser_basicFunctionality.js
new file mode 100644
index 0000000000..c8f0fd68b7
--- /dev/null
+++ b/comm/calendar/test/browser/browser_basicFunctionality.js
@@ -0,0 +1,78 @@
+/* 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/. */
+
+/* globals createCalendarUsingDialog */
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+add_task(async function testBasicFunctionality() {
+  const calendarName = "Mochitest";
+
+  registerCleanupFunction(() => {
+    for (let calendar of cal.manager.getCalendars()) {
+      if (calendar.name == calendarName) {
+        cal.manager.removeCalendar(calendar);
+      }
+    }
+    Services.focus.focusedWindow = window;
+  });
+
+  Services.focus.focusedWindow = window;
+
+  // Create test calendar.
+  await createCalendarUsingDialog(calendarName);
+
+  // Check for minimonth, every month has a day 1.
+  Assert.ok(
+    document.querySelector("#calMinimonth .minimonth-cal-box td[aria-label='1']"),
+    "day 1 exists in the minimonth"
+  );
+
+  // Check for calendar list.
+  Assert.ok(document.querySelector("#calendar-list-pane"), "calendar list pane exists");
+  Assert.ok(document.querySelector("#calendar-list"), "calendar list exists");
+
+  // Check for event search.
+  Assert.ok(document.querySelector("#bottom-events-box"), "event search box exists");
+
+  // There should be search field.
+  Assert.ok(document.querySelector("#unifinder-search-field"), "unifinded search field exists");
+
+  // Make sure the week view is the default selected view.
+  Assert.ok(
+    document
+      .querySelector(`.calview-toggle-item[aria-selected="true"]`)
+      .getAttribute("aria-controls") == "week-view",
+    "week-view toggle is the current default"
+  );
+
+  let dayViewButton = document.querySelector("#calTabDay");
+  dayViewButton.click();
+  Assert.ok(dayViewButton.getAttribute("aria-selected"), "day view button is selected");
+  await CalendarTestUtils.ensureViewLoaded(window);
+
+  // Day view should have 09:00 box.
+  let someTime = cal.createDateTime();
+  someTime.resetTo(someTime.year, someTime.month, someTime.day, 9, 0, 0, someTime.timezone);
+  let label = cal.dtz.formatter.formatTime(someTime);
+  let labelEl = document.querySelectorAll("#day-view .multiday-timebar .multiday-hour-box")[9];
+  Assert.ok(labelEl, "9th hour box should exist");
+  Assert.equal(labelEl.textContent, label, "9th hour box should show the correct time");
+  Assert.ok(CalendarTestUtils.dayView.getHourBoxAt(window, 9), "09:00 box exists");
+
+  // Open tasks view.
+  document.querySelector("#tasksButton").click();
+
+  // Should be possible to filter today's tasks.
+  Assert.ok(document.querySelector("#opt_today_filter"), "show today radio button exists");
+
+  // Check for task add button.
+  Assert.ok(document.querySelector("#calendar-add-task-button"), "task add button exists");
+
+  // Check for filtered tasks list.
+  Assert.ok(
+    document.querySelector("#calendar-task-tree .calendar-task-treechildren"),
+    "filtered tasks list exists"
+  );
+});
diff --git a/comm/calendar/test/browser/browser_calDAV_discovery.js b/comm/calendar/test/browser/browser_calDAV_discovery.js
new file mode 100644
index 0000000000..217bf76f55
--- /dev/null
+++ b/comm/calendar/test/browser/browser_calDAV_discovery.js
@@ -0,0 +1,241 @@
+/* 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 { CalDAVServer } = ChromeUtils.import("resource://testing-common/calendar/CalDAVServer.jsm");
+var { DNS } = ChromeUtils.import("resource:///modules/DNS.jsm");
+
+async function openWizard(...args) {
+  await CalendarTestUtils.openCalendarTab(window);
+  let wizardPromise = BrowserTestUtils.promiseAlertDialog(
+    undefined,
+    "chrome://calendar/content/calendar-creation.xhtml",
+    {
+      callback: wizardWindow => handleWizard(wizardWindow, ...args),
+    }
+  );
+  EventUtils.synthesizeMouseAtCenter(
+    document.querySelector("#newCalendarSidebarButton"),
+    {},
+    window
+  );
+  return wizardPromise;
+}
+
+async function handleWizard(wizardWindow, { username, url, password, expectedCalendars }) {
+  let wizardDocument = wizardWindow.document;
+  let acceptButton = wizardDocument.querySelector("dialog").getButton("accept");
+  let cancelButton = wizardDocument.querySelector("dialog").getButton("cancel");
+
+  // Select calendar type.
+
+  EventUtils.synthesizeMouseAtCenter(
+    wizardDocument.querySelector(`radio[value="network"]`),
+    {},
+    wizardWindow
+  );
+  EventUtils.synthesizeMouseAtCenter(acceptButton, {}, wizardWindow);
+
+  // Network calendar settings.
+
+  Assert.ok(acceptButton.disabled);
+  Assert.equal(wizardDocument.activeElement.id, "network-username-input");
+  if (username) {
+    EventUtils.sendString(username, wizardWindow);
+  }
+
+  if (username?.includes("@")) {
+    Assert.equal(
+      wizardDocument.getElementById("network-location-input").placeholder,
+      username.replace(/^.*@/, "")
+    );
+  }
+
+  EventUtils.synthesizeKey("VK_TAB", {}, wizardWindow);
+  Assert.equal(wizardDocument.activeElement.id, "network-location-input");
+  if (url) {
+    EventUtils.sendString(url, wizardWindow);
+  }
+
+  Assert.ok(!acceptButton.disabled);
+
+  let promptPromise = handlePasswordPrompt(password);
+  EventUtils.synthesizeKey("VK_RETURN", {}, wizardWindow);
+  await promptPromise;
+
+  // Select calendars.
+
+  let list = wizardDocument.getElementById("network-calendar-list");
+  await TestUtils.waitForCondition(
+    () => BrowserTestUtils.is_visible(list),
+    "waiting for calendar list to appear",
+    200,
+    100
+  );
+
+  Assert.equal(list.childElementCount, expectedCalendars.length);
+  for (let i = 0; i < expectedCalendars.length; i++) {
+    let item = list.children[i];
+
+    Assert.equal(item.calendar.uri.spec, expectedCalendars[i].uri);
+    Assert.equal(
+      item.querySelector(".calendar-color").style.backgroundColor,
+      expectedCalendars[i].color
+    );
+    Assert.equal(item.querySelector(".calendar-name").value, expectedCalendars[i].name);
+
+    if (expectedCalendars[i].hasOwnProperty("readOnly")) {
+      Assert.equal(
+        item.calendar.readOnly,
+        expectedCalendars[i].readOnly,
+        `calendar read-only property is ${expectedCalendars[i].readOnly}`
+      );
+    }
+  }
+  EventUtils.synthesizeMouseAtCenter(cancelButton, {}, wizardWindow);
+}
+
+async function handlePasswordPrompt(password) {
+  return BrowserTestUtils.promiseAlertDialog(null, undefined, {
+    async callback(prompt) {
+      await new Promise(resolve => prompt.setTimeout(resolve));
+
+      prompt.document.getElementById("password1Textbox").value = password;
+
+      let checkbox = prompt.document.getElementById("checkbox");
+      Assert.greater(checkbox.getBoundingClientRect().width, 0);
+      Assert.ok(checkbox.checked);
+
+      prompt.document.querySelector("dialog").getButton("accept").click();
+    },
+  });
+}
+
+/**
+ * Test that we correctly use DNS discovery. This uses the mochitest server
+ * (files in the data directory) instead of CalDAVServer because the latter
+ * can't speak HTTPS, and we only do DNS discovery for HTTPS.
+ */
+add_task(async function testDNS() {
+  var _srv = DNS.srv;
+  var _txt = DNS.txt;
+  DNS.srv = function (name) {
+    Assert.equal(name, "_caldavs._tcp.dnstest.invalid");
+    return [{ prio: 0, weight: 0, host: "example.org", port: 443 }];
+  };
+  DNS.txt = function (name) {
+    Assert.equal(name, "_caldavs._tcp.dnstest.invalid");
+    return [{ data: "path=/browser/comm/calendar/test/browser/data/dns.sjs" }];
+  };
+
+  await openWizard({
+    username: "carol@dnstest.invalid",
+    password: "carol",
+    expectedCalendars: [
+      {
+        uri: "https://example.org/browser/comm/calendar/test/browser/data/calendar.sjs",
+        name: "You found me!",
+        color: "rgb(0, 128, 0)",
+      },
+      {
+        uri: "https://example.org/browser/comm/calendar/test/browser/data/calendar2.sjs",
+        name: "Röda dagar",
+        color: "rgb(255, 0, 0)",
+      },
+    ],
+  });
+
+  DNS.srv = _srv;
+  DNS.txt = _txt;
+});
+
+/**
+ * Test that the magic URL /.well-known/caldav works.
+ */
+add_task(async function testWellKnown() {
+  CalDAVServer.open("alice", "alice");
+
+  await openWizard({
+    username: "alice",
+    url: CalDAVServer.origin,
+    password: "alice",
+    expectedCalendars: [
+      {
+        uri: CalDAVServer.url,
+        name: "CalDAV Test",
+        color: "rgb(255, 128, 0)",
+      },
+    ],
+  });
+
+  CalDAVServer.close();
+});
+
+/**
+ * Tests calendars with only the "read" "current-user-privilege-set" are
+ * flagged read-only.
+ */
+add_task(async function testCalendarWithOnlyReadPriv() {
+  CalDAVServer.open("alice", "alice");
+  CalDAVServer.privileges = "<d:privilege><d:read/></d:privilege>";
+  await openWizard({
+    username: "alice",
+    url: CalDAVServer.origin,
+    password: "alice",
+    expectedCalendars: [
+      {
+        uri: CalDAVServer.url,
+        name: "CalDAV Test",
+        color: "rgb(255, 128, 0)",
+        readOnly: true,
+      },
+    ],
+  });
+  CalDAVServer.close();
+});
+
+/**
+ * Tests calendars that return none of the expected values for "current-user-privilege-set"
+ * are flagged read-only.
+ */
+add_task(async function testCalendarWithoutPrivs() {
+  CalDAVServer.open("alice", "alice");
+  CalDAVServer.privileges = "";
+  await openWizard({
+    username: "alice",
+    url: CalDAVServer.origin,
+    password: "alice",
+    expectedCalendars: [
+      {
+        uri: CalDAVServer.url,
+        name: "CalDAV Test",
+        color: "rgb(255, 128, 0)",
+        readOnly: true,
+      },
+    ],
+  });
+  CalDAVServer.close();
+});
+
+/**
+ * Tests calendars that return status 404 for "current-user-privilege-set" are
+ * not flagged read-only.
+ */
+add_task(async function testCalendarWithNoPrivSupport() {
+  CalDAVServer.open("alice", "alice");
+  CalDAVServer.privileges = null;
+  await openWizard({
+    username: "alice",
+    url: CalDAVServer.origin,
+    password: "alice",
+    expectedCalendars: [
+      {
+        uri: CalDAVServer.url,
+        name: "CalDAV Test",
+        color: "rgb(255, 128, 0)",
+        readOnly: false,
+      },
+    ],
+  });
+  CalDAVServer.close();
+});
diff --git a/comm/calendar/test/browser/browser_calDAV_oAuth.js b/comm/calendar/test/browser/browser_calDAV_oAuth.js
new file mode 100644
index 0000000000..4d9c733076
--- /dev/null
+++ b/comm/calendar/test/browser/browser_calDAV_oAuth.js
@@ -0,0 +1,201 @@
+/* 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/. */
+
+// Creates calendars in various configurations (current and legacy) and performs
+// requests in each of them to prove that OAuth2 authentication is working as expected.
+
+var { CalDavCalendar } = ChromeUtils.import("resource:///modules/CalDavCalendar.jsm");
+var { CalDavGenericRequest } = ChromeUtils.import("resource:///modules/caldav/CalDavRequest.jsm");
+
+var LoginInfo = Components.Constructor(
+  "@mozilla.org/login-manager/loginInfo;1",
+  Ci.nsILoginInfo,
+  "init"
+);
+
+// Ideal login info. This is what would be saved if you created a new calendar.
+const ORIGIN = "oauth://mochi.test";
+const SCOPE = "test_scope";
+const USERNAME = "bob@test.invalid";
+const VALID_TOKEN = "bobs_refresh_token";
+
+/**
+ * Set a string pref for the given calendar.
+ *
+ * @param {string} calendarId
+ * @param {string} key
+ * @param {string} value
+ */
+function setPref(calendarId, key, value) {
+  Services.prefs.setStringPref(`calendar.registry.${calendarId}.${key}`, value);
+}
+
+/**
+ * Clear any existing saved logins and add the given ones.
+ *
+ * @param {string[][]} - Zero or more arrays consisting of origin, realm, username, and password.
+ */
+function setLogins(...logins) {
+  Services.logins.removeAllLogins();
+  for (let [origin, realm, username, password] of logins) {
+    Services.logins.addLogin(new LoginInfo(origin, null, realm, username, password, "", ""));
+  }
+}
+
+/**
+ * Create a calendar with the given id, perform a request, and check that the correct
+ * authorisation header was used. If the user is required to re-authenticate with the provider,
+ * check that the new token is stored in the right place.
+ *
+ * @param {string} calendarId - ID of the new calendar
+ * @param {string} [newTokenUsername] - If given, re-authentication must happen and the new token
+ *   stored with this user name.
+ */
+async function subtest(calendarId, newTokenUsername) {
+  let calendar = new CalDavCalendar();
+  calendar.id = calendarId;
+
+  let request = new CalDavGenericRequest(
+    calendar.wrappedJSObject.session,
+    calendar,
+    "GET",
+    Services.io.newURI(
+      "http://mochi.test:8888/browser/comm/mail/components/addrbook/test/browser/data/auth_headers.sjs"
+    )
+  );
+  let response = await request.commit();
+  let headers = JSON.parse(response.text);
+
+  if (newTokenUsername) {
+    Assert.equal(headers.authorization, "Bearer new_access_token");
+
+    let logins = Services.logins
+      .findLogins(ORIGIN, null, SCOPE)
+      .filter(l => l.username == newTokenUsername);
+    Assert.equal(logins.length, 1);
+    Assert.equal(logins[0].username, newTokenUsername);
+    Assert.equal(logins[0].password, "new_refresh_token");
+  } else {
+    Assert.equal(headers.authorization, "Bearer bobs_access_token");
+  }
+
+  Services.logins.removeAllLogins();
+}
+
+// Test making a request when there is no matching token stored.
+
+/** No token stored, no username or session ID set. */
+add_task(function testCalendarOAuth_id_none() {
+  let calendarId = "testCalendarOAuth_id_none";
+  return subtest(calendarId, calendarId);
+});
+
+/** No token stored, session ID set. */
+add_task(function testCalendarOAuth_sessionId_none() {
+  let calendarId = "testCalendarOAuth_sessionId_none";
+  setPref(calendarId, "sessionId", "test_session");
+  return subtest(calendarId, "test_session");
+});
+
+/** No token stored, username set. */
+add_task(function testCalendarOAuth_username_none() {
+  let calendarId = "testCalendarOAuth_username_none";
+  setPref(calendarId, "username", USERNAME);
+  return subtest(calendarId, USERNAME);
+});
+
+// Test making a request when there IS a matching token, but the server rejects it.
+// Currently a new token is not requested on failure.
+
+/** Expired token stored with calendar ID. */
+add_task(function testCalendarOAuth_id_expired() {
+  let calendarId = "testCalendarOAuth_id_expired";
+  setLogins([`oauth:${calendarId}`, "Google CalDAV v2", calendarId, "expired_token"]);
+  return subtest(calendarId, calendarId);
+}).skip(); // Broken.
+
+/** Expired token stored with session ID. */
+add_task(function testCalendarOAuth_sessionId_expired() {
+  let calendarId = "testCalendarOAuth_sessionId_expired";
+  setPref(calendarId, "sessionId", "test_session");
+  setLogins(["oauth:test_session", "Google CalDAV v2", "test_session", "expired_token"]);
+  return subtest(calendarId, "test_session");
+}).skip(); // Broken.
+
+/** Expired token stored with calendar ID, username set. */
+add_task(function testCalendarOAuth_username_expired() {
+  let calendarId = "testCalendarOAuth_username_expired";
+  setPref(calendarId, "username", USERNAME);
+  setLogins([`oauth:${calendarId}`, "Google CalDAV v2", calendarId, "expired_token"]);
+  return subtest(calendarId, USERNAME);
+}).skip(); // Broken.
+
+// Test making a request with a valid token, using Lightning's client ID and secret.
+
+/** Valid token stored with calendar ID. */
+add_task(function testCalendarOAuth_id_valid() {
+  let calendarId = "testCalendarOAuth_id_valid";
+  setLogins([`oauth:${calendarId}`, "Google CalDAV v2", calendarId, VALID_TOKEN]);
+  return subtest(calendarId);
+});
+
+/** Valid token stored with session ID. */
+add_task(function testCalendarOAuth_sessionId_valid() {
+  let calendarId = "testCalendarOAuth_sessionId_valid";
+  setPref(calendarId, "sessionId", "test_session");
+  setLogins(["oauth:test_session", "Google CalDAV v2", "test_session", VALID_TOKEN]);
+  return subtest(calendarId);
+});
+
+/** Valid token stored with calendar ID, username set. */
+add_task(function testCalendarOAuth_username_valid() {
+  let calendarId = "testCalendarOAuth_username_valid";
+  setPref(calendarId, "username", USERNAME);
+  setLogins([`oauth:${calendarId}`, "Google CalDAV v2", calendarId, VALID_TOKEN]);
+  return subtest(calendarId, USERNAME);
+});
+
+// Test making a request with a valid token, using Thunderbird's client ID and secret.
+
+/** Valid token stored with calendar ID. */
+add_task(function testCalendarOAuthTB_id_valid() {
+  let calendarId = "testCalendarOAuthTB_id_valid";
+  setLogins([ORIGIN, SCOPE, calendarId, VALID_TOKEN]);
+  return subtest(calendarId);
+});
+
+/** Valid token stored with session ID. */
+add_task(function testCalendarOAuthTB_sessionId_valid() {
+  let calendarId = "testCalendarOAuthTB_sessionId_valid";
+  setPref(calendarId, "sessionId", "test_session");
+  setLogins([ORIGIN, SCOPE, "test_session", VALID_TOKEN]);
+  return subtest(calendarId);
+});
+
+/** Valid token stored with calendar ID, username set. */
+add_task(function testCalendarOAuthTB_username_valid() {
+  let calendarId = "testCalendarOAuthTB_username_valid";
+  setPref(calendarId, "username", USERNAME);
+  setLogins([ORIGIN, SCOPE, calendarId, VALID_TOKEN]);
+  return subtest(calendarId, USERNAME);
+});
+
+/** Valid token stored with username, exact scope. */
+add_task(function testCalendarOAuthTB_username_validSingle() {
+  let calendarId = "testCalendarOAuthTB_username_validSingle";
+  setPref(calendarId, "username", USERNAME);
+  setLogins(
+    [ORIGIN, SCOPE, USERNAME, VALID_TOKEN],
+    [ORIGIN, "other_scope", USERNAME, "other_refresh_token"]
+  );
+  return subtest(calendarId);
+});
+
+/** Valid token stored with username, many scopes. */
+add_task(function testCalendarOAuthTB_username_validMultiple() {
+  let calendarId = "testCalendarOAuthTB_username_validMultiple";
+  setPref(calendarId, "username", USERNAME);
+  setLogins([ORIGIN, "scope test_scope other_scope", USERNAME, VALID_TOKEN]);
+  return subtest(calendarId);
+});
diff --git a/comm/calendar/test/browser/browser_calendarList.js b/comm/calendar/test/browser/browser_calendarList.js
new file mode 100644
index 0000000000..b85ef5a56e
--- /dev/null
+++ b/comm/calendar/test/browser/browser_calendarList.js
@@ -0,0 +1,341 @@
+/* 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/. */
+
+async function calendarListContextMenu(target, menuItem) {
+  await new Promise(r => setTimeout(r));
+  window.focus();
+  await TestUtils.waitForCondition(
+    () => Services.focus.focusedWindow == window,
+    "waiting for window to be focused"
+  );
+
+  // The test frequently times out if we don't wait here. Unknown why.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(r => setTimeout(r, 250));
+
+  let contextMenu = document.getElementById("list-calendars-context-menu");
+  let shownPromise = BrowserTestUtils.waitForEvent(contextMenu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(target, { type: "contextmenu" });
+  await shownPromise;
+
+  if (menuItem) {
+    let hiddenPromise = BrowserTestUtils.waitForEvent(contextMenu, "popuphidden");
+    contextMenu.activateItem(document.getElementById(menuItem));
+    await hiddenPromise;
+  }
+}
+
+async function withMockPromptService(response, callback) {
+  let realPrompt = Services.prompt;
+  Services.prompt = {
+    QueryInterface: ChromeUtils.generateQI(["nsIPromptService"]),
+    confirmEx: (unused1, unused2, text) => {
+      info(text);
+      return response;
+    },
+  };
+  await callback();
+  Services.prompt = realPrompt;
+}
+
+add_task(async () => {
+  function checkProperties(index, expected) {
+    let calendarList = document.getElementById("calendar-list");
+    let item = calendarList.rows[index];
+    let colorImage = item.querySelector(".calendar-color");
+    for (let [key, expectedValue] of Object.entries(expected)) {
+      switch (key) {
+        case "id":
+          Assert.equal(item.getAttribute("calendar-id"), expectedValue);
+          break;
+        case "disabled":
+          Assert.equal(item.querySelector(".calendar-displayed").hidden, expectedValue);
+          break;
+        case "displayed":
+          Assert.equal(item.querySelector(".calendar-displayed").checked, expectedValue);
+          break;
+        case "color":
+          if (item.hasAttribute("calendar-disabled")) {
+            Assert.equal(getComputedStyle(colorImage).backgroundColor, "rgba(0, 0, 0, 0)");
+          } else {
+            Assert.equal(getComputedStyle(colorImage).backgroundColor, expectedValue);
+          }
+          break;
+        case "name":
+          Assert.equal(item.querySelector(".calendar-name").textContent, expectedValue);
+          break;
+      }
+    }
+  }
+
+  function checkDisplayed(...expected) {
+    let calendarList = document.getElementById("calendar-list");
+    Assert.greater(calendarList.rowCount, Math.max(...expected));
+    for (let i = 0; i < calendarList.rowCount; i++) {
+      Assert.equal(
+        calendarList.rows[i].querySelector(".calendar-displayed").checked,
+        expected.includes(i)
+      );
+    }
+  }
+
+  function checkSortOrder(...expected) {
+    let orderPref = Services.prefs.getStringPref("calendar.list.sortOrder", "wrong");
+    Assert.notEqual(orderPref, "wrong", "sort order pref has a value");
+    let order = orderPref.split(" ");
+    Assert.equal(order.length, expected.length, "sort order length");
+    for (let i = 0; i < expected.length; i++) {
+      Assert.equal(order[i], calendars[expected[i]].id, "sort order ids");
+    }
+  }
+
+  let calendarList = document.getElementById("calendar-list");
+  let contextMenu = document.getElementById("list-calendars-context-menu");
+  let composite = cal.view.getCompositeCalendar(window);
+
+  await CalendarTestUtils.openCalendarTab(window);
+
+  // Check the default calendar.
+  let calendars = cal.manager.getCalendars();
+  Assert.equal(calendars.length, 1);
+  Assert.equal(calendarList.rowCount, 1);
+  checkProperties(0, {
+    color: "rgb(168, 194, 225)",
+    name: "Home",
+  });
+  checkSortOrder(0);
+
+  // Test adding calendars.
+
+  // Open and then cancel the 'create calendar' dialog, just to prove that the
+  // context menu works.
+  let dialogPromise = BrowserTestUtils.promiseAlertDialog(
+    "cancel",
+    "chrome://calendar/content/calendar-creation.xhtml"
+  );
+  calendarListContextMenu(calendarList, "list-calendars-context-new");
+  await dialogPromise;
+
+  // Add some new calendars, check their properties.
+  for (let i = 1; i <= 3; i++) {
+    calendars[i] = CalendarTestUtils.createCalendar(`Mochitest ${i}`, "memory");
+  }
+
+  Assert.equal(cal.manager.getCalendars().length, 4);
+  Assert.equal(calendarList.rowCount, 4);
+
+  for (let i = 1; i <= 3; i++) {
+    checkProperties(i, {
+      id: calendars[i].id,
+      displayed: true,
+      color: "rgb(168, 194, 225)",
+      name: `Mochitest ${i}`,
+    });
+  }
+  checkSortOrder(0, 1, 2, 3);
+
+  // Test the context menu.
+
+  await new Promise(resolve => setTimeout(resolve));
+  EventUtils.synthesizeMouseAtCenter(calendarList.rows[1], {});
+  await new Promise(resolve => setTimeout(resolve));
+  await calendarListContextMenu(calendarList.rows[1]);
+  await new Promise(resolve => setTimeout(resolve));
+  Assert.equal(
+    document.getElementById("list-calendars-context-togglevisible").label,
+    "Hide Mochitest 1"
+  );
+  Assert.equal(
+    document.getElementById("list-calendars-context-showonly").label,
+    "Show Only Mochitest 1"
+  );
+  Assert.ok(
+    document.getElementById("list-calendar-context-reload").hidden,
+    "Local calendar should have reload menu showing"
+  );
+  contextMenu.hidePopup();
+
+  Assert.equal(document.activeElement, calendarList);
+  Assert.equal(calendarList.rows[calendarList.selectedIndex], calendarList.rows[1]);
+
+  // Test show/hide.
+  // TODO: Check events on calendars are hidden/shown.
+
+  EventUtils.synthesizeMouseAtCenter(calendarList.rows[2].querySelector(".calendar-displayed"), {});
+  Assert.equal(document.activeElement, calendarList);
+  Assert.equal(calendarList.rows[calendarList.selectedIndex], calendarList.rows[2]);
+  Assert.equal(composite.getCalendarById(calendars[2].id), null);
+  checkDisplayed(0, 1, 3);
+
+  composite.removeCalendar(calendars[1]);
+  checkDisplayed(0, 3);
+
+  await calendarListContextMenu(calendarList.rows[3], "list-calendars-context-togglevisible");
+  checkDisplayed(0);
+
+  EventUtils.synthesizeMouseAtCenter(calendarList.rows[2].querySelector(".calendar-displayed"), {});
+  Assert.equal(composite.getCalendarById(calendars[2].id), calendars[2]);
+  Assert.equal(document.activeElement, calendarList);
+  Assert.equal(calendarList.rows[calendarList.selectedIndex], calendarList.rows[2]);
+  checkDisplayed(0, 2);
+
+  composite.addCalendar(calendars[1]);
+  checkDisplayed(0, 1, 2);
+
+  await calendarListContextMenu(calendarList.rows[3], "list-calendars-context-togglevisible");
+  checkDisplayed(0, 1, 2, 3);
+
+  await calendarListContextMenu(calendarList.rows[1], "list-calendars-context-showonly");
+  checkDisplayed(1);
+
+  await calendarListContextMenu(calendarList, "list-calendars-context-showall");
+  checkDisplayed(0, 1, 2, 3);
+
+  // Test editing calendars.
+
+  dialogPromise = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-properties-dialog.xhtml",
+    {
+      callback(win) {
+        let doc = win.document;
+        let nameElement = doc.getElementById("calendar-name");
+        let colorElement = doc.getElementById("calendar-color");
+        Assert.equal(nameElement.value, "Mochitest 1");
+        Assert.equal(colorElement.value, "#a8c2e1");
+        nameElement.value = "A New Calendar!";
+        colorElement.value = "#009900";
+        doc.querySelector("dialog").getButton("accept").click();
+      },
+    }
+  );
+  EventUtils.synthesizeMouseAtCenter(calendarList.rows[1], { clickCount: 2 });
+  await dialogPromise;
+
+  Assert.equal(document.activeElement, calendarList);
+  Assert.equal(calendarList.rows[calendarList.selectedIndex], calendarList.rows[1]);
+  checkProperties(1, {
+    color: "rgb(0, 153, 0)",
+    name: "A New Calendar!",
+  });
+
+  dialogPromise = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-properties-dialog.xhtml",
+    {
+      callback(win) {
+        let doc = win.document;
+        let nameElement = doc.getElementById("calendar-name");
+        let colorElement = doc.getElementById("calendar-color");
+        Assert.equal(nameElement.value, "A New Calendar!");
+        Assert.equal(colorElement.value, "#009900");
+        nameElement.value = "Mochitest 1";
+        doc.querySelector("dialog").getButton("accept").click();
+      },
+    }
+  );
+  calendarListContextMenu(calendarList.rows[1], "list-calendars-context-edit");
+  await dialogPromise;
+
+  Assert.equal(document.activeElement, calendarList);
+  Assert.equal(calendarList.rows[calendarList.selectedIndex], calendarList.rows[1]);
+  checkProperties(1, {
+    color: "rgb(0, 153, 0)",
+    name: "Mochitest 1",
+  });
+
+  dialogPromise = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-properties-dialog.xhtml",
+    {
+      callback(win) {
+        let doc = win.document;
+        Assert.equal(doc.getElementById("calendar-name").value, "Mochitest 3");
+        let enabledElement = doc.getElementById("calendar-enabled-checkbox");
+        Assert.ok(enabledElement.checked);
+        enabledElement.checked = false;
+        doc.querySelector("dialog").getButton("accept").click();
+      },
+    }
+  );
+  // We're clicking on an item that wasn't the selected one. Selection should be updated.
+  calendarListContextMenu(calendarList.rows[3], "list-calendars-context-edit");
+  await dialogPromise;
+
+  Assert.equal(document.activeElement, calendarList);
+  Assert.equal(calendarList.rows[calendarList.selectedIndex], calendarList.rows[3]);
+  checkProperties(3, { disabled: true });
+
+  calendars[3].setProperty("disabled", false);
+  checkProperties(3, { disabled: false });
+
+  // Test reordering calendars.
+
+  let dragSession = Cc["@mozilla.org/widget/dragservice;1"].getService(Ci.nsIDragService);
+  dragSession.startDragSessionForTests(Ci.nsIDragService.DRAGDROP_ACTION_MOVE);
+
+  await new Promise(resolve => window.setTimeout(resolve));
+
+  let [result, dataTransfer] = EventUtils.synthesizeDragOver(
+    calendarList.rows[3],
+    calendarList.rows[0],
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    {
+      screenY: calendarList.rows[0].getBoundingClientRect().top + 1,
+    }
+  );
+  await new Promise(resolve => setTimeout(resolve));
+
+  EventUtils.synthesizeDropAfterDragOver(result, dataTransfer, calendarList.rows[0]);
+  EventUtils.sendDragEvent({ type: "dragend" }, calendarList.rows[0]);
+  dragSession.endDragSession(true);
+  await new Promise(resolve => setTimeout(resolve));
+
+  checkSortOrder(3, 0, 1, 2);
+
+  Assert.equal(document.activeElement, calendarList);
+  Assert.equal(calendarList.rows[calendarList.selectedIndex], calendarList.rows[0]);
+
+  // Test deleting calendars.
+
+  // Delete a calendar by unregistering it.
+  CalendarTestUtils.removeCalendar(calendars[3]);
+  Assert.equal(cal.manager.getCalendars().length, 3);
+  Assert.equal(calendarList.rowCount, 3);
+  checkSortOrder(0, 1, 2);
+
+  // Start to remove a calendar. Cancel the prompt.
+  EventUtils.synthesizeMouseAtCenter(calendarList.rows[1], {});
+  await withMockPromptService(1, () => {
+    EventUtils.synthesizeKey("VK_DELETE");
+  });
+  Assert.equal(cal.manager.getCalendars().length, 3, "three calendars left in the manager");
+  Assert.equal(calendarList.rowCount, 3, "three calendars left in the list");
+  checkSortOrder(0, 1, 2);
+
+  // Remove a calendar with the keyboard.
+  await withMockPromptService(0, () => {
+    EventUtils.synthesizeKey("VK_DELETE");
+  });
+  Assert.equal(cal.manager.getCalendars().length, 2, "two calendars left in the manager");
+  Assert.equal(calendarList.rowCount, 2, "two calendars left in the list");
+  checkSortOrder(0, 2);
+
+  // Remove a calendar with the context menu.
+  await withMockPromptService(0, async () => {
+    EventUtils.synthesizeMouseAtCenter(calendarList.rows[1], {});
+    await calendarListContextMenu(calendarList.rows[1], "list-calendars-context-delete");
+  });
+
+  Assert.equal(cal.manager.getCalendars().length, 1, "one calendar left in the manager");
+  Assert.equal(calendarList.rowCount, 1, "one calendar left in the list");
+  checkSortOrder(0);
+
+  Assert.equal(composite.defaultCalendar.id, calendars[0].id, "default calendar id check");
+  Assert.equal(calendarList.rows[calendarList.selectedIndex], calendarList.rows[0]);
+  await CalendarTestUtils.closeCalendarTab(window);
+});
diff --git a/comm/calendar/test/browser/browser_calendarTelemetry.js b/comm/calendar/test/browser/browser_calendarTelemetry.js
new file mode 100644
index 0000000000..cf2dff7a55
--- /dev/null
+++ b/comm/calendar/test/browser/browser_calendarTelemetry.js
@@ -0,0 +1,119 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+/**
+ * Test telemetry related to calendar.
+ */
+
+let { MailTelemetryForTests } = ChromeUtils.import("resource:///modules/MailGlue.jsm");
+let { TelemetryTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TelemetryTestUtils.sys.mjs"
+);
+
+/**
+ * Check that we're counting calendars and read only calendars.
+ */
+add_task(async function testCalendarCount() {
+  Services.telemetry.clearScalars();
+
+  let calendars = cal.manager.getCalendars();
+  let homeCal = calendars.find(cal => cal.name == "Home");
+  let readOnly = homeCal.readOnly;
+  homeCal.readOnly = true;
+
+  for (let i = 1; i <= 3; i++) {
+    calendars[i] = CalendarTestUtils.createCalendar(`Mochitest ${i}`, "memory");
+    if (i === 1 || i === 3) {
+      calendars[i].readOnly = true;
+    }
+  }
+
+  await MailTelemetryForTests.reportCalendars();
+
+  let scalars = TelemetryTestUtils.getProcessScalars("parent", true);
+  Assert.equal(
+    scalars["tb.calendar.calendar_count"].memory,
+    3,
+    "Count of calendars must be correct."
+  );
+  Assert.equal(
+    scalars["tb.calendar.read_only_calendar_count"].memory,
+    2,
+    "Count of readonly calendars must be correct."
+  );
+
+  Assert.ok(
+    !scalars["tb.calendar.calendar_count"].storage,
+    "'Home' calendar not included in count while disabled"
+  );
+
+  Assert.ok(
+    !scalars["tb.calendar.read_only_calendar_count"].storage,
+    "'Home' calendar not included in read-only count while disabled"
+  );
+
+  for (let i = 1; i <= 3; i++) {
+    CalendarTestUtils.removeCalendar(calendars[i]);
+  }
+  homeCal.readOnly = readOnly;
+});
+
+/**
+ * Ensure the "Home" calendar is not ignored if it has been used.
+ */
+add_task(async function testHomeCalendar() {
+  let calendar = cal.manager.getCalendars().find(cal => cal.name == "Home");
+  let readOnly = calendar.readOnly;
+  let disabled = calendar.getProperty("disabled");
+
+  // Test when enabled with no events.
+  calendar.setProperty("disabled", false);
+  calendar.readOnly = true;
+  Services.telemetry.clearScalars();
+  await MailTelemetryForTests.reportCalendars();
+
+  let scalars = TelemetryTestUtils.getProcessScalars("parent", true);
+  Assert.ok(!scalars["tb.calendar.calendar_count"], "'Home' calendar not counted when unused");
+  Assert.ok(
+    !scalars["tb.calendar.read_only_calendar_count"],
+    "'Home' calendar not included in readonly count when unused"
+  );
+
+  // Now test with an event added to the calendar.
+  calendar.readOnly = false;
+
+  let event = new CalEvent();
+  event.id = "bacd";
+  event.title = "Test";
+  event.startDate = cal.dtz.now();
+  event = await calendar.addItem(event);
+
+  calendar.readOnly = true;
+
+  await TestUtils.waitForCondition(async () => {
+    let result = await calendar.getItem("bacd");
+    return result;
+  }, "item added to calendar");
+
+  Services.telemetry.clearScalars();
+  await MailTelemetryForTests.reportCalendars();
+
+  scalars = TelemetryTestUtils.getProcessScalars("parent", true);
+  Assert.equal(
+    scalars["tb.calendar.calendar_count"].storage,
+    1,
+    "'Home' calendar counted when there are items"
+  );
+  Assert.equal(
+    scalars["tb.calendar.read_only_calendar_count"].storage,
+    1,
+    "'Home' calendar included in read-only count when used"
+  );
+
+  calendar.readOnly = false;
+  await calendar.deleteItem(event);
+  calendar.readOnly = readOnly;
+  calendar.setProperty("disabled", disabled);
+});
diff --git a/comm/calendar/test/browser/browser_calendarUnifinder.js b/comm/calendar/test/browser/browser_calendarUnifinder.js
new file mode 100644
index 0000000000..7020b70f71
--- /dev/null
+++ b/comm/calendar/test/browser/browser_calendarUnifinder.js
@@ -0,0 +1,76 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+const { mailTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/MailTestUtils.jsm"
+);
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalRecurrenceInfo: "resource:///modules/CalRecurrenceInfo.jsm",
+});
+
+/**
+ * Tests clicking on events opens in the summary dialog for both
+ * non-recurring and recurring events.
+ */
+add_task(async function testOpenEvent() {
+  let uri = Services.io.newURI("moz-memory-calendar://");
+  let calendar = cal.manager.createCalendar("memory", uri);
+
+  calendar.name = "Unifinder Test";
+  cal.manager.registerCalendar(calendar);
+  registerCleanupFunction(() => cal.manager.removeCalendar(calendar));
+
+  let now = cal.dtz.now();
+
+  let noRepeatEvent = new CalEvent();
+  noRepeatEvent.id = "no repeat event";
+  noRepeatEvent.title = "No Repeat Event";
+  noRepeatEvent.startDate = now;
+  noRepeatEvent.endDate = noRepeatEvent.startDate.clone();
+  noRepeatEvent.endDate.hour++;
+
+  let repeatEvent = new CalEvent();
+  repeatEvent.id = "repeated event";
+  repeatEvent.title = "Repeat Event";
+  repeatEvent.startDate = now;
+  repeatEvent.endDate = noRepeatEvent.startDate.clone();
+  repeatEvent.endDate.hour++;
+  repeatEvent.recurrenceInfo = new CalRecurrenceInfo(repeatEvent);
+  repeatEvent.recurrenceInfo.appendRecurrenceItem(
+    cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=30")
+  );
+
+  await CalendarTestUtils.openCalendarTab(window);
+
+  if (window.isUnifinderHidden()) {
+    window.toggleUnifinder();
+
+    await BrowserTestUtils.waitForCondition(
+      () => window.isUnifinderHidden(),
+      "calendar unifinder is open"
+    );
+  }
+
+  for (let event of [noRepeatEvent, repeatEvent]) {
+    await calendar.addItem(event);
+
+    let dialogWindowPromise = CalendarTestUtils.waitForEventDialog();
+    let tree = document.querySelector("#unifinder-search-results-tree");
+    mailTestUtils.treeClick(EventUtils, window, tree, 0, 1, { clickCount: 2 });
+
+    let dialogWindow = await dialogWindowPromise;
+    let docUri = dialogWindow.document.documentURI;
+    Assert.ok(
+      docUri === "chrome://calendar/content/calendar-summary-dialog.xhtml",
+      "event summary dialog did show"
+    );
+
+    await BrowserTestUtils.closeWindow(dialogWindow);
+    await calendar.deleteItem(event);
+  }
+});
diff --git a/comm/calendar/test/browser/browser_dragEventItem.js b/comm/calendar/test/browser/browser_dragEventItem.js
new file mode 100644
index 0000000000..204e429fdd
--- /dev/null
+++ b/comm/calendar/test/browser/browser_dragEventItem.js
@@ -0,0 +1,414 @@
+/* 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/. */
+
+/**
+ * Test dragging of events in the various calendar views.
+ */
+const { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+const calendar = CalendarTestUtils.createCalendar("Drag Test", "memory");
+// Set a low number of hours to reduce pixel -> minute rounding errors.
+Services.prefs.setIntPref("calendar.view.visiblehours", 3);
+
+registerCleanupFunction(() => {
+  CalendarTestUtils.removeCalendar(calendar);
+  Services.prefs.clearUserPref("calendar.view.visiblehours");
+  // Reset the spaces toolbar to its default visible state.
+  window.gSpacesToolbar.toggleToolbar(false);
+});
+
+/**
+ * Ensures that the window is maximised after switching dates.
+ *
+ * @param {calIDateTime} date - A date to navigate the view to.
+ */
+async function resetView(date, view) {
+  window.goToDate(date);
+
+  if (window.windowState != window.STATE_MAXIMIZED) {
+    // The multi-day views adjust scrolling dynamically when they detect a
+    // resize. Hook into the resize event and scroll after the adjustment.
+    let resizePromise = BrowserTestUtils.waitForEvent(window, "resize");
+    window.maximize();
+    await resizePromise;
+  }
+}
+
+/**
+ * End the dragging of the event at the specified location.
+ *
+ * @param {number} day - The day to drop into.
+ * @param {number} hour - The starting hour to drop to.
+ * @param {number} topOffset - An offset to apply to the mouse position.
+ */
+function endDrag(day, hour, topOffset) {
+  let view = window.currentView();
+  let hourElement;
+  if (view.id == "day-view") {
+    hourElement = CalendarTestUtils.dayView.getHourBoxAt(window, hour);
+  } else {
+    hourElement = CalendarTestUtils.weekView.getHourBoxAt(window, day, hour);
+  }
+  // We scroll to align the *end* of the hour element so we can avoid triggering
+  // the auto-scroll when we synthesize mousemove below.
+  // FIXME: Use and test auto scroll by holding mouseover at the view edges.
+  CalendarTestUtils.scrollViewToTarget(hourElement, false);
+
+  let hourRect = hourElement.getBoundingClientRect();
+
+  // We drop the event with some offset from the starting edge of the desired
+  // hourElement.
+  // NOTE: This may mean that the drop point may not be above the hourElement.
+  // NOTE: We assume that the drop point is however still above the view.
+  // Currently event "move" events get cancelled if the pointer leaves the view.
+  let top = Math.round(hourRect.top + topOffset);
+  let left = Math.round(hourRect.left + hourRect.width / 2);
+
+  EventUtils.synthesizeMouseAtPoint(left, top, { type: "mousemove", shiftKey: true }, window);
+  EventUtils.synthesizeMouseAtPoint(left, top, { type: "mouseup", shiftKey: true }, window);
+}
+
+/**
+ * Simulates the dragging of an event box in a multi-day view to another
+ * column, horizontally.
+ *
+ * @param {MozCalendarEventBox} eventBox - The event to start moving.
+ * @param {number} day - The day to drop into.
+ * @param {number} hour - The starting hour to drop to.
+ */
+function simulateDragToColumn(eventBox, day, hour) {
+  // Scroll to align to the top of the view.
+  CalendarTestUtils.scrollViewToTarget(eventBox, true);
+
+  let sourceRect = eventBox.getBoundingClientRect();
+  // Start dragging from the center of the event box to avoid the gripbars.
+  // NOTE: We assume that the eventBox's center is in view.
+  let leftOffset = sourceRect.width / 2;
+  // We round the mouse position to try and reduce rounding errors when
+  // scrolling the view.
+  let sourceTop = Math.round(sourceRect.top + sourceRect.height / 2);
+  let sourceLeft = sourceRect.left + leftOffset;
+  // Keep track of the exact offset.
+  let topOffset = sourceTop - sourceRect.top;
+
+  EventUtils.synthesizeMouseAtPoint(
+    sourceLeft,
+    sourceTop,
+    // Hold shift to avoid snapping.
+    { type: "mousedown", shiftKey: true },
+    window
+  );
+  EventUtils.synthesizeMouseAtPoint(
+    // We assume the location of the mouseout event does not matter, just as
+    // long as the event box receives it.
+    sourceLeft,
+    sourceTop,
+    { type: "mouseout", shiftKey: true },
+    window
+  );
+
+  // End drag with the same offset from the starting edge.
+  endDrag(day, hour, topOffset);
+}
+
+/**
+ * Simulates the dragging of an event box via one of the gripbars.
+ *
+ * @param {MozCalendarEventBox} eventBox - The event to resize.
+ * @param {"start"|"end"} - The side to grab.
+ * @param {number} day - The day to move into.
+ * @param {number} hour - The hour to move to.
+ */
+function simulateGripbarDrag(eventBox, side, day, hour) {
+  // Scroll the edge of the box into view.
+  CalendarTestUtils.scrollViewToTarget(eventBox, side == "start");
+
+  let gripbar = side == "start" ? eventBox.startGripbar : eventBox.endGripbar;
+
+  let sourceRect = gripbar.getBoundingClientRect();
+  let sourceTop = sourceRect.top + sourceRect.height / 2;
+  let sourceLeft = sourceRect.left + sourceRect.width / 2;
+
+  // Hover to make the gripbar visible.
+  EventUtils.synthesizeMouseAtPoint(sourceLeft, sourceTop, { type: "mouseover" }, window);
+  EventUtils.synthesizeMouseAtPoint(
+    sourceLeft,
+    sourceTop,
+    // Hold shift to avoid snapping.
+    { type: "mousedown", shiftKey: true },
+    window
+  );
+
+  // End the drag at the start of the hour.
+  endDrag(day, hour, 0);
+}
+
+/**
+ * Tests dragging an event item updates the event in the month view.
+ */
+add_task(async function testMonthViewDragEventItem() {
+  let event = new CalEvent();
+  event.id = "1";
+  event.title = "Month View Event";
+  event.startDate = cal.createDateTime("20210316T000000Z");
+  event.endDate = cal.createDateTime("20210316T110000Z");
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  await calendar.addItem(event);
+  await resetView(event.startDate);
+
+  // Hide the spaces toolbar since it interferes with the calendar
+  window.gSpacesToolbar.toggleToolbar(true);
+
+  let eventItem = await CalendarTestUtils.monthView.waitForItemAt(window, 3, 3, 1);
+  let dayBox = await CalendarTestUtils.monthView.getDayBox(window, 3, 2);
+  let dragSession = Cc["@mozilla.org/widget/dragservice;1"].getService(Ci.nsIDragService);
+  dragSession.startDragSessionForTests(Ci.nsIDragService.DRAGDROP_ACTION_MOVE);
+
+  let [result, dataTransfer] = EventUtils.synthesizeDragOver(
+    eventItem,
+    dayBox,
+    undefined,
+    undefined,
+    eventItem.ownerGlobal,
+    dayBox.ownerGlobal
+  );
+  EventUtils.synthesizeDropAfterDragOver(result, dataTransfer, dayBox);
+  dragSession.endDragSession(true);
+
+  Assert.ok(
+    !CalendarTestUtils.monthView.getItemAt(window, 3, 3, 1),
+    "item removed from initial date"
+  );
+
+  eventItem = await CalendarTestUtils.monthView.waitForItemAt(window, 3, 2, 1);
+  Assert.ok(eventItem, "item moved to new date");
+
+  let { id, title, startDate, endDate } = eventItem.occurrence;
+  Assert.equal(id, event.id, "id is correct");
+  Assert.equal(title, event.title, "title is correct");
+  Assert.equal(startDate.icalString, "20210315T000000Z", "startDate is correct");
+  Assert.equal(endDate.icalString, "20210315T110000Z", "endDate is correct");
+  await calendar.deleteItem(eventItem.occurrence);
+});
+
+/**
+ * Tests dragging an event item updates the event in the multiweek view.
+ */
+add_task(async function testMultiWeekViewDragEventItem() {
+  let event = new CalEvent();
+  event.id = "2";
+  event.title = "Multiweek View Event";
+  event.startDate = cal.createDateTime("20210316T000000Z");
+  event.endDate = cal.createDateTime("20210316T110000Z");
+
+  await CalendarTestUtils.setCalendarView(window, "multiweek");
+  await calendar.addItem(event);
+  await resetView(event.startDate);
+
+  let eventItem = await CalendarTestUtils.multiweekView.waitForItemAt(window, 1, 3, 1);
+  let dayBox = await CalendarTestUtils.multiweekView.getDayBox(window, 1, 2);
+  let dragSession = Cc["@mozilla.org/widget/dragservice;1"].getService(Ci.nsIDragService);
+  dragSession.startDragSessionForTests(Ci.nsIDragService.DRAGDROP_ACTION_MOVE);
+
+  let [result, dataTransfer] = EventUtils.synthesizeDragOver(
+    eventItem,
+    dayBox,
+    undefined,
+    undefined,
+    eventItem.ownerGlobal,
+    dayBox.ownerGlobal
+  );
+  EventUtils.synthesizeDropAfterDragOver(result, dataTransfer, dayBox);
+  dragSession.endDragSession(true);
+
+  Assert.ok(
+    !CalendarTestUtils.multiweekView.getItemAt(window, 1, 3, 1),
+    "item removed from initial date"
+  );
+
+  eventItem = await CalendarTestUtils.multiweekView.waitForItemAt(window, 1, 2, 1);
+  Assert.ok(eventItem, "item moved to new date");
+
+  let { id, title, startDate, endDate } = eventItem.occurrence;
+  Assert.equal(id, event.id, "id is correct");
+  Assert.equal(title, event.title, "title is correct");
+  Assert.equal(startDate.icalString, "20210315T000000Z", "startDate is correct");
+  Assert.equal(endDate.icalString, "20210315T110000Z", "endDate is correct");
+  await calendar.deleteItem(eventItem.occurrence);
+});
+
+/**
+ * Tests dragging an event box to the previous day updates the event in the
+ * week view.
+ */
+add_task(async function testWeekViewDragEventBoxToPreviousDay() {
+  let event = new CalEvent();
+  event.id = "3";
+  event.title = "Week View Previous Day";
+  event.startDate = cal.createDateTime("20210316T020000Z");
+  event.endDate = cal.createDateTime("20210316T030000Z");
+
+  await CalendarTestUtils.setCalendarView(window, "week");
+  await calendar.addItem(event);
+  await resetView(event.startDate);
+
+  let eventBox = await CalendarTestUtils.weekView.waitForEventBoxAt(window, 3, 1);
+  simulateDragToColumn(eventBox, 2, 2);
+
+  eventBox = await CalendarTestUtils.weekView.waitForEventBoxAt(window, 2, 1);
+  await TestUtils.waitForCondition(
+    () => !CalendarTestUtils.weekView.getEventBoxAt(window, 3, 1),
+    "Old position is empty"
+  );
+
+  let { id, title, startDate, endDate } = eventBox.occurrence;
+  Assert.equal(id, event.id, "id is correct");
+  Assert.equal(title, event.title, "title is correct");
+  Assert.equal(startDate.icalString, "20210315T020000Z", "startDate is correct");
+  Assert.equal(endDate.icalString, "20210315T030000Z", "endDate is correct");
+  await calendar.deleteItem(eventBox.occurrence);
+});
+
+/**
+ * Tests dragging an event box to the following day updates the event in the
+ * week view.
+ */
+add_task(async function testWeekViewDragEventBoxToFollowingDay() {
+  let event = new CalEvent();
+  event.id = "4";
+  event.title = "Week View Following Day";
+  event.startDate = cal.createDateTime("20210316T020000Z");
+  event.endDate = cal.createDateTime("20210316T030000Z");
+
+  await CalendarTestUtils.setCalendarView(window, "week");
+  await calendar.addItem(event);
+  await resetView(event.startDate);
+
+  let eventBox = await CalendarTestUtils.weekView.waitForEventBoxAt(window, 3, 1);
+  simulateDragToColumn(eventBox, 4, 2);
+
+  eventBox = await CalendarTestUtils.weekView.waitForEventBoxAt(window, 4, 1);
+  await TestUtils.waitForCondition(
+    () => !CalendarTestUtils.weekView.getEventBoxAt(window, 3, 1),
+    "Old position is empty"
+  );
+
+  let { id, title, startDate, endDate } = eventBox.occurrence;
+  Assert.equal(id, event.id, "id is correct");
+  Assert.equal(title, event.title, "title is correct");
+  Assert.equal(startDate.icalString, "20210317T020000Z", "startDate is correct");
+  Assert.equal(endDate.icalString, "20210317T030000Z", "endDate is correct");
+  await calendar.deleteItem(eventBox.occurrence);
+});
+
+/**
+ * Tests dragging the top of an event box updates the start time in the week
+ * view.
+ */
+add_task(async function testWeekViewDragEventBoxStartTime() {
+  let event = new CalEvent();
+  event.id = "5";
+  event.title = "Week View Start";
+  event.startDate = cal.createDateTime("20210316T020000Z");
+  event.endDate = cal.createDateTime("20210316T030000Z");
+
+  await CalendarTestUtils.setCalendarView(window, "week");
+  await calendar.addItem(event);
+  await resetView(event.startDate);
+
+  let eventBox = await CalendarTestUtils.weekView.waitForEventBoxAt(window, 3, 1);
+  simulateGripbarDrag(eventBox, "start", 3, 1);
+  eventBox = await CalendarTestUtils.weekView.waitForEventBoxAt(window, 3, 1);
+
+  let { id, title, startDate, endDate } = eventBox.occurrence;
+  Assert.equal(id, event.id, "id is correct");
+  Assert.equal(title, event.title, "title is correct");
+  Assert.equal(startDate.icalString, "20210316T010000Z", "startDate was changed");
+  Assert.equal(endDate.icalString, "20210316T030000Z", "endDate did not change");
+  await calendar.deleteItem(eventBox.occurrence);
+});
+
+/**
+ * Tests dragging the end of an event box changes the time in the week view.
+ */
+add_task(async function testWeekViewDragEventBoxEndTime() {
+  let event = new CalEvent();
+  event.id = "6";
+  event.title = "Week View End";
+  event.startDate = cal.createDateTime("20210316T020000Z");
+  event.endDate = cal.createDateTime("20210316T030000Z");
+
+  await CalendarTestUtils.setCalendarView(window, "week");
+  await calendar.addItem(event);
+  await resetView(event.startDate);
+
+  let eventBox = await CalendarTestUtils.weekView.waitForEventBoxAt(window, 3, 1);
+  simulateGripbarDrag(eventBox, "end", 3, 6);
+  eventBox = await CalendarTestUtils.weekView.waitForEventBoxAt(window, 3, 1);
+
+  let { id, title, startDate, endDate } = eventBox.occurrence;
+  Assert.equal(id, event.id, "id is correct");
+  Assert.equal(title, event.title, "title is correct");
+  Assert.equal(startDate.icalString, "20210316T020000Z", "startDate did not change");
+  Assert.equal(endDate.icalString, "20210316T060000Z", "endDate was changed");
+  await calendar.deleteItem(eventBox.occurrence);
+});
+
+/**
+ * Tests dragging the top of an event box changes the start time in the day view.
+ */
+add_task(async function testDayViewDragEventBoxStartTime() {
+  let event = new CalEvent();
+  event.id = "7";
+  event.title = "Day View Start";
+  event.startDate = cal.createDateTime("20210316T020000Z");
+  event.endDate = cal.createDateTime("20210316T030000Z");
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await calendar.addItem(event);
+  await resetView(event.startDate);
+
+  let eventBox = await CalendarTestUtils.dayView.waitForEventBoxAt(window, 1);
+  simulateGripbarDrag(eventBox, "start", 1, 1);
+  eventBox = await CalendarTestUtils.dayView.waitForEventBoxAt(window, 1);
+
+  let { id, title, startDate, endDate } = eventBox.occurrence;
+  Assert.equal(id, event.id, "id is correct");
+  Assert.equal(title, event.title, "title is correct");
+  Assert.equal(startDate.icalString, "20210316T010000Z", "startDate was changed");
+  Assert.equal(endDate.icalString, "20210316T030000Z", "endDate did not change");
+  await calendar.deleteItem(eventBox.occurrence);
+});
+
+/**
+ * Tests dragging the bottom of an event box changes the end time in the day
+ * view.
+ */
+add_task(async function testDayViewDragEventBoxEndTime() {
+  let event = new CalEvent();
+  event.id = "8";
+  event.title = "Day View End";
+  event.startDate = cal.createDateTime("20210316T020000Z");
+  event.endDate = cal.createDateTime("20210316T030000Z");
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await calendar.addItem(event);
+  await resetView(event.startDate);
+
+  let eventBox = await CalendarTestUtils.dayView.waitForEventBoxAt(window, 1);
+  simulateGripbarDrag(eventBox, "end", 1, 4);
+  eventBox = await CalendarTestUtils.dayView.waitForEventBoxAt(window, 1);
+
+  let { id, title, startDate, endDate } = eventBox.occurrence;
+  Assert.equal(id, event.id, "id is correct");
+  Assert.equal(title, event.title, "title is correct");
+  Assert.equal(startDate.icalString, "20210316T020000Z", "startDate did not change");
+  Assert.equal(endDate.icalString, "20210316T040000Z", "endDate was changed");
+  await calendar.deleteItem(eventBox.occurrence);
+});
diff --git a/comm/calendar/test/browser/browser_eventDisplay_dayView.js b/comm/calendar/test/browser/browser_eventDisplay_dayView.js
new file mode 100644
index 0000000000..5f0941cac4
--- /dev/null
+++ b/comm/calendar/test/browser/browser_eventDisplay_dayView.js
@@ -0,0 +1,133 @@
+/* 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/. */
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+var calendar = CalendarTestUtils.createCalendar();
+registerCleanupFunction(() => {
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+/**
+ * Create an event item in the calendar.
+ *
+ * @param {string} name - The name of the event.
+ * @param {string} start - The date time string for the start of the event.
+ * @param {string} end - The date time string for the end of the event.
+ *
+ * @returns {CalEvent} - The created event.
+ */
+async function createEvent(name, start, end) {
+  let event = new CalEvent();
+  event.title = name;
+  event.startDate = cal.createDateTime(start);
+  event.endDate = cal.createDateTime(end);
+  return calendar.addItem(event);
+}
+
+/**
+ * Assert that there is an event shown on the given date in the day-view.
+ *
+ * @param {object} date - The date to move to.
+ * @param {number} date.day - The day.
+ * @param {number} date.week - The week.
+ * @param {number} date.year - The year.
+ * @param {object} expect - Details about the expected event.
+ * @param {string} expect.name - The event name.
+ * @param {boolean} expect.startInView - Whether the event starts within the
+ *   view on the given date.
+ * @param {boolean} expect.endInView - Whether the event ends within the view
+ *   on the given date.
+ * @param {string} message - A message to use in assertions.
+ */
+async function assertDayEvent(date, expect, message) {
+  await CalendarTestUtils.goToDate(window, date.year, date.month, date.day);
+  let element = await CalendarTestUtils.dayView.waitForEventBoxAt(window, 1);
+  Assert.equal(
+    element.querySelector(".event-name-label").textContent,
+    expect.name,
+    `Event name should match: ${message}`
+  );
+  await CalendarTestUtils.assertEventBoxDraggable(
+    element,
+    expect.startInView,
+    expect.endInView,
+    message
+  );
+}
+
+/**
+ * Test an event that occurs within one day, in the day view.
+ */
+add_task(async function testInsideDayView() {
+  let event = await createEvent("Test Event", "20190403T123400", "20190403T234500");
+  await CalendarTestUtils.setCalendarView(window, "day");
+  Assert.equal(
+    document.querySelectorAll("#day-view calendar-event-column").length,
+    1,
+    "1 day column in the day view"
+  );
+
+  // This event is fully within this view.
+  await assertDayEvent(
+    { day: 3, month: 4, year: 2019 },
+    { name: "Test Event", startInView: true, endInView: true },
+    "Single day event"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Test an event that starts and ends at midnight, in the day view.
+ */
+add_task(async function testMidnightDayView() {
+  let event = await createEvent("Test Event", "20190403T000000", "20190404T000000");
+  await CalendarTestUtils.setCalendarView(window, "day");
+
+  // This event is fully within this view.
+  await assertDayEvent(
+    { day: 3, month: 4, year: 2019 },
+    { name: "Test Event", startInView: true, endInView: true },
+    "Single midnight event"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Test an event that spans multiple days, in the day view.
+ */
+add_task(async function testOutsideDayView() {
+  let event = await createEvent("Test Event", "20190402T123400", "20190404T234500");
+  await CalendarTestUtils.setCalendarView(window, "day");
+
+  // Go to the start of the event. The end of the event is beyond the current view.
+  await assertDayEvent(
+    { day: 2, month: 4, year: 2019 },
+    { name: "Test Event", startInView: true, endInView: false },
+    "First day"
+  );
+
+  // Go to the middle of the event. Both ends of the event are beyond the current view.
+  await assertDayEvent(
+    { day: 3, month: 4, year: 2019 },
+    { name: "Test Event", startInView: false, endInView: false },
+    "Middle day"
+  );
+
+  // Go to the end of the event. The start of the event is beyond the current view.
+  await assertDayEvent(
+    { day: 4, month: 4, year: 2019 },
+    { name: "Test Event", startInView: false, endInView: true },
+    "Last day"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
diff --git a/comm/calendar/test/browser/browser_eventDisplay_multiWeekView.js b/comm/calendar/test/browser/browser_eventDisplay_multiWeekView.js
new file mode 100644
index 0000000000..91ddeec6ac
--- /dev/null
+++ b/comm/calendar/test/browser/browser_eventDisplay_multiWeekView.js
@@ -0,0 +1,275 @@
+/* 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/. */
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+var calendar = CalendarTestUtils.createCalendar();
+registerCleanupFunction(() => {
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+/**
+ * Create an event item in the calendar.
+ *
+ * @param {string} name - The name of the event.
+ * @param {string} start - The date time string for the start of the event.
+ * @param {string} end - The date time string for the end of the event.
+ *
+ * @returns {Promise<CalEvent>} - The created event.
+ */
+function createEvent(name, start, end) {
+  let event = new CalEvent();
+  event.title = name;
+  event.startDate = cal.createDateTime(start);
+  event.endDate = cal.createDateTime(end);
+  return calendar.addItem(event);
+}
+
+/**
+ * Assert that there is a an event in the multiweek or month view between the
+ * expected range, and no events on the other days.
+ *
+ * @param {"multiweek"|"month"} viewName - The view to test.
+ * @param {number} numWeeks - The number of weeks shown in the view.
+ * @param {object} date - The date to move to.
+ * @param {number} date.day - The day.
+ * @param {number} date.week - The week.
+ * @param {number} date.year - The year.
+ * @param {object} expect - Details about the expected event.
+ * @param {string} expect.name - The event name.
+ * @param {number} expect.start - The day that the event should start in the
+ *   week. Between 1 and 7.
+ * @param {number} expect.end - The day that the event should end in the week.
+ * @param {boolean} expect.startInView - Whether the event starts within the
+ *   view on the given date.
+ * @param {boolean} expect.endInView - Whether the event ends within the view
+ *   on the given date.
+ * @param {string} message - A message to use in assertions.
+ */
+async function assertMultiweekEvents(viewName, numWeeks, date, expect, message) {
+  await CalendarTestUtils.goToDate(window, date.year, date.month, date.day);
+  let view =
+    viewName == "multiweek" ? CalendarTestUtils.multiweekView : CalendarTestUtils.monthView;
+
+  // start = (startWeek - 1) * 7 + startDay
+  let startWeek = Math.floor((expect.start - 1) / 7) + 1;
+  let startDay = ((expect.start - 1) % 7) + 1;
+  let endWeek = Math.floor((expect.end - 1) / 7) + 1;
+  let endDay = ((expect.end - 1) % 7) + 1;
+  for (let week = startWeek; week <= endWeek; week++) {
+    let start = week == startWeek ? startDay : 1;
+    let end = week == endWeek ? endDay : 7;
+    for (let day = start; day <= end; day++) {
+      let element = await view.waitForItemAt(window, week, day, 1);
+      Assert.equal(
+        element.querySelector(".event-name-label").textContent,
+        expect.name,
+        `Week ${week}, day ${day} event name should match: ${message}`
+      );
+      let multidayIcon = element.querySelector(".item-type-icon");
+      if (startDay == endDay && week == startWeek && day == startDay) {
+        Assert.equal(multidayIcon.src, "", `Week ${week}, day ${day} icon has no source`);
+      } else if (expect.startInView && week == startWeek && day == startDay) {
+        Assert.equal(
+          multidayIcon.src,
+          "chrome://calendar/skin/shared/event-start.svg",
+          `Week ${week}, day ${day} icon src shows event start: ${message}`
+        );
+      } else if (expect.endInView && week == endWeek && day == endDay) {
+        Assert.equal(
+          multidayIcon.src,
+          "chrome://calendar/skin/shared/event-end.svg",
+          `Week ${week}, day ${day} icon src shows event end: ${message}`
+        );
+      } else {
+        Assert.equal(
+          multidayIcon.src,
+          "chrome://calendar/skin/shared/event-continue.svg",
+          `Week ${week}, day ${day} icon src shows event continue: ${message}`
+        );
+      }
+    }
+  }
+  Assert.equal(
+    numWeeks,
+    document.querySelectorAll(`#${viewName}-view .monthbody tr:not([hidden])`).length,
+    `Should show ${numWeeks} weeks in the view: ${message}`
+  );
+  // Test no events loaded on the other days.
+  for (let week = 1; week <= numWeeks; week++) {
+    for (let day = 1; day <= 7; day++) {
+      if (
+        (week > startWeek && week < endWeek) ||
+        (week == startWeek && day >= startDay) ||
+        (week == endWeek && day <= endDay)
+      ) {
+        continue;
+      }
+      Assert.ok(
+        !view.getItemAt(window, week, day, 1),
+        `Should be no events on day ${day}: ${message}`
+      );
+    }
+  }
+}
+
+/**
+ * Test an event that occurs fully within the multi-week view.
+ */
+add_task(async function testInsideMultiweekView() {
+  let event = await createEvent("Test Event", "20190402T123400", "20190419T234500");
+  await CalendarTestUtils.setCalendarView(window, "multiweek");
+  Assert.equal(
+    document.querySelectorAll("#multiweek-view tr:not([hidden]) calendar-month-day-box").length,
+    28,
+    "28 days in the multiweek view"
+  );
+
+  await assertMultiweekEvents(
+    "multiweek",
+    4,
+    { day: 1, month: 4, year: 2019 },
+    { name: "Test Event", start: 3, end: 20, startInView: true, endInView: true },
+    "3 week event in multiweek view"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Test an event that starts and ends at midnight, in the multi-week view.
+ */
+add_task(async function testMidnightMultiweekView() {
+  // Event spans one day.
+  let event = await createEvent("Test Event", "20190402T000000", "20190403T000000");
+  await CalendarTestUtils.setCalendarView(window, "multiweek");
+
+  await assertMultiweekEvents(
+    "multiweek",
+    4,
+    { day: 1, month: 4, year: 2019 },
+    { name: "Test Event", start: 3, end: 3, startInView: true, endInView: true },
+    "one day midnight event in multiweek"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Test an event that starts or ends outside the multi-week view.
+ */
+add_task(async function testOutsideMultiweekView() {
+  let event = await createEvent("Test Event", "20190402T123400", "20190507T234500");
+  await CalendarTestUtils.setCalendarView(window, "multiweek");
+
+  await assertMultiweekEvents(
+    "multiweek",
+    4,
+    { day: 11, month: 3, year: 2019 },
+    { name: "Test Event", start: 24, end: 28, startInView: true, endInView: false },
+    "First block in multiweek"
+  );
+
+  await assertMultiweekEvents(
+    "multiweek",
+    4,
+    { day: 8, month: 4, year: 2019 },
+    { name: "Test Event", start: 1, end: 28, startInView: false, endInView: false },
+    "Middle block in multiweek"
+  );
+
+  await assertMultiweekEvents(
+    "multiweek",
+    4,
+    { day: 29, month: 4, year: 2019 },
+    { name: "Test Event", start: 1, end: 10, startInView: false, endInView: true },
+    "End block in multiweek"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Test an event that occurs within one month, in the month view.
+ */
+add_task(async function testInsideMonthView() {
+  let event = await createEvent("Test Event", "20190702T123400", "20190719T234500");
+  await CalendarTestUtils.setCalendarView(window, "month");
+  Assert.equal(
+    document.querySelectorAll("#month-view tr:not([hidden]) calendar-month-day-box").length,
+    35,
+    "35 days in the month view"
+  );
+
+  await assertMultiweekEvents(
+    "month",
+    5,
+    { day: 1, month: 7, year: 2019 },
+    { name: "Test Event", start: 3, end: 20, startInView: true, endInView: true },
+    "Event in single month"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Test an event that starts and ends at midnight, in the month view.
+ */
+add_task(async function testMidnightMonthView() {
+  // Event spans three days.
+  let event = await createEvent("Test Event", "20190702T000000", "20190705T000000");
+  await CalendarTestUtils.setCalendarView(window, "month");
+
+  await assertMultiweekEvents(
+    "month",
+    5,
+    { day: 1, month: 7, year: 2019 },
+    { name: "Test Event", start: 3, end: 5, startInView: true, endInView: true },
+    "3 day midnight event in single month"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Test an event that spans multiple months, in the month view.
+ */
+add_task(async function testOutsideMonthView() {
+  let event = await createEvent("Test Event", "20190320T123400", "20190507T234500");
+  await CalendarTestUtils.setCalendarView(window, "month");
+
+  await assertMultiweekEvents(
+    "month",
+    6,
+    { day: 1, month: 3, year: 2019 },
+    { name: "Test Event", start: 25, end: 42, startInView: true, endInView: false },
+    "First month"
+  );
+
+  await assertMultiweekEvents(
+    "month",
+    5,
+    { day: 1, month: 4, year: 2019 },
+    { name: "Test Event", start: 1, end: 35, startInView: false, endInView: false },
+    "Middle month"
+  );
+
+  await assertMultiweekEvents(
+    "month",
+    5,
+    { day: 1, month: 5, year: 2019 },
+    { name: "Test Event", start: 1, end: 10, startInView: false, endInView: true },
+    "End month"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
diff --git a/comm/calendar/test/browser/browser_eventDisplay_weekView.js b/comm/calendar/test/browser/browser_eventDisplay_weekView.js
new file mode 100644
index 0000000000..806105c29a
--- /dev/null
+++ b/comm/calendar/test/browser/browser_eventDisplay_weekView.js
@@ -0,0 +1,151 @@
+/* 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/. */
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+var calendar = CalendarTestUtils.createCalendar();
+registerCleanupFunction(() => {
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+/**
+ * Create an event item in the calendar.
+ *
+ * @param {string} name - The name of the event.
+ * @param {string} start - The date time string for the start of the event.
+ * @param {string} end - The date time string for the end of the event.
+ *
+ * @returns {CalEvent} - The created event.
+ */
+async function createEvent(name, start, end) {
+  let event = new CalEvent();
+  event.title = name;
+  event.startDate = cal.createDateTime(start);
+  event.endDate = cal.createDateTime(end);
+  return calendar.addItem(event);
+}
+
+/**
+ * Assert that there is a an event in the week-view between the expected range,
+ * and no events on the other days.
+ *
+ * @param {object} date - The date to move to.
+ * @param {number} date.day - The day.
+ * @param {number} date.week - The week.
+ * @param {number} date.year - The year.
+ * @param {object} expect - Details about the expected event.
+ * @param {string} expect.name - The event name.
+ * @param {number} expect.start - The day that the event should start in the
+ *   week. Between 1 and 7.
+ * @param {number} expect.end - The day that the event should end in the week.
+ * @param {boolean} expect.startInView - Whether the event starts within the
+ *   view on the given date.
+ * @param {boolean} expect.endInView - Whether the event ends within the view
+ *   on the given date.
+ * @param {string} message - A message to use in assertions.
+ */
+async function assertWeekEvents(date, expect, message) {
+  await CalendarTestUtils.goToDate(window, date.year, date.month, date.day);
+  // First test for expected events since these can take a short while to load,
+  // and we don't want to test for the absence of an event before they show.
+  for (let day = expect.start; day <= expect.end; day++) {
+    let element = await CalendarTestUtils.weekView.waitForEventBoxAt(window, day, 1);
+    Assert.equal(
+      element.querySelector(".event-name-label").textContent,
+      expect.name,
+      `Day ${day} event name should match: ${message}`
+    );
+    let icon = element.querySelector(".item-recurrence-icon");
+    Assert.equal(icon.src, "");
+    Assert.ok(icon.hidden);
+    await CalendarTestUtils.assertEventBoxDraggable(
+      element,
+      expect.startInView && day == expect.start,
+      expect.endInView && day == expect.end,
+      `Day ${day}: ${message}`
+    );
+  }
+  // Test no events loaded on the other days.
+  for (let day = 1; day <= 7; day++) {
+    if (day >= expect.start && day <= expect.end) {
+      continue;
+    }
+    Assert.equal(
+      CalendarTestUtils.weekView.getEventBoxes(window, day).length,
+      0,
+      `Should be no events on day ${day}: ${message}`
+    );
+  }
+}
+
+/**
+ * Test an event that occurs within one week, in the week view.
+ */
+add_task(async function testInsideWeekView() {
+  let event = await createEvent("Test Event", "20190101T123400", "20190103T234500");
+  await CalendarTestUtils.setCalendarView(window, "week");
+  Assert.equal(
+    document.querySelectorAll("#week-view calendar-event-column").length,
+    7,
+    "7 day columns in the week view"
+  );
+
+  await assertWeekEvents(
+    { day: 1, month: 1, year: 2019 },
+    { name: "Test Event", start: 3, end: 5, startInView: true, endInView: true },
+    "Single week event"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Test an event that starts and ends at midnight, in the week view.
+ */
+add_task(async function testMidnightWeekView() {
+  // Spans three days.
+  let event = await createEvent("Test Event", "20190101T000000", "20190104T000000");
+  await CalendarTestUtils.setCalendarView(window, "week");
+
+  // Midnight-to-midnight event only spans one day even though the end time
+  // matches the starting time of the next day (midnight).
+  await assertWeekEvents(
+    { day: 1, month: 1, year: 2019 },
+    { name: "Test Event", start: 3, end: 5, startInView: true, endInView: true },
+    "Midnight week event"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Test an event that spans multiple weeks, in the week view.
+ */
+add_task(async function testOutsideWeekView() {
+  let event = await createEvent("Test Event", "20190402T123400", "20190418T234500");
+  await CalendarTestUtils.setCalendarView(window, "week");
+
+  await assertWeekEvents(
+    { day: 3, month: 4, year: 2019 },
+    { name: "Test Event", start: 3, end: 7, startInView: true, endInView: false },
+    "First week"
+  );
+  await assertWeekEvents(
+    { day: 10, month: 4, year: 2019 },
+    { name: "Test Event", start: 1, end: 7, startInView: false, endInView: false },
+    "Middle week"
+  );
+  await assertWeekEvents(
+    { day: 17, month: 4, year: 2019 },
+    { name: "Test Event", start: 1, end: 5, startInView: false, endInView: true },
+    "Last week"
+  );
+
+  await CalendarTestUtils.closeCalendarTab(window);
+  await calendar.deleteItem(event);
+});
diff --git a/comm/calendar/test/browser/browser_eventUndoRedo.js b/comm/calendar/test/browser/browser_eventUndoRedo.js
new file mode 100644
index 0000000000..34ea8d0523
--- /dev/null
+++ b/comm/calendar/test/browser/browser_eventUndoRedo.js
@@ -0,0 +1,260 @@
+/* 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/. */
+
+"use strict";
+
+/**
+ * Tests for ensuring the undo/redo options are enabled properly when
+ * manipulating events.
+ */
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalTransactionManager: "resource:///modules/CalTransactionManager.jsm",
+});
+
+const calendar = CalendarTestUtils.createCalendar("Undo Redo Test");
+const calTransManager = CalTransactionManager.getInstance();
+
+/**
+ * Checks the value of the "disabled" property for items in either the "Edit"
+ * menu bar or the app menu. Display of the relevant menu is triggered first so
+ * the UI code can update the respective items.
+ *
+ * @param {XULElement} element - The menu item we want to check, if its id begins
+ *                               with "menu" then we assume it is in the menu
+ *                               bar, if "appmenu" then the app menu.
+ */
+async function isDisabled(element) {
+  let targetMenu = document.getElementById("menu_EditPopup");
+
+  let shownPromise = BrowserTestUtils.waitForEvent(targetMenu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("menu_Edit"), {});
+  await shownPromise;
+
+  let hiddenPromise = BrowserTestUtils.waitForEvent(targetMenu, "popuphidden");
+  let status = element.disabled;
+  targetMenu.hidePopup();
+  await hiddenPromise;
+  return status;
+}
+
+async function clickItem(element) {
+  let targetMenu = document.getElementById("menu_EditPopup");
+
+  let shownPromise = BrowserTestUtils.waitForEvent(targetMenu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("menu_Edit"), {});
+  await shownPromise;
+
+  targetMenu.activateItem(element);
+}
+
+/**
+ * Removes CalTransaction items from the CalTransactionManager stacks so other
+ * tests are unhindered.
+ */
+function clearTransactions() {
+  calTransManager.undoStack = [];
+  calTransManager.redoStack = [];
+}
+
+/**
+ * Test the undo/redo functionality for event creation.
+ *
+ * @param {string} undoId - The id of the "undo" menu item.
+ * @param {string} redoId - The id of the "redo" menu item.
+ */
+async function testAddUndoRedoEvent(undoId, redoId) {
+  let undo = document.getElementById(undoId);
+  let redo = document.getElementById(redoId);
+  Assert.ok(await isDisabled(undo), `#${undoId} is disabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  let newBtn = document.getElementById("sidePanelNewEvent");
+  let windowOpened = CalendarTestUtils.waitForEventDialog("edit");
+  EventUtils.synthesizeMouseAtCenter(newBtn, {});
+
+  let win = await windowOpened;
+  let iframeWin = win.document.getElementById("calendar-item-panel-iframe").contentWindow;
+  await CalendarTestUtils.items.setData(win, iframeWin, { title: "A New Event" });
+  await CalendarTestUtils.items.saveAndCloseItemDialog(win);
+
+  let eventItem;
+  await TestUtils.waitForCondition(() => {
+    eventItem = document.querySelector("calendar-month-day-box-item");
+    return eventItem;
+  }, "event not created in time");
+
+  Assert.ok(!(await isDisabled(undo)), `#${undoId} is enabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  // Test undo.
+  await clickItem(undo);
+  await TestUtils.waitForCondition(() => {
+    eventItem = document.querySelector("calendar-month-day-box-item");
+    return !eventItem;
+  }, "undo did not remove item in time");
+
+  Assert.ok(!eventItem, `#${undoId} reverses item creation`);
+
+  // Test redo.
+  await clickItem(redo);
+  await TestUtils.waitForCondition(() => {
+    eventItem = document.querySelector("calendar-month-day-box-item");
+    return eventItem;
+  }, `${redoId} did not re-create item in time`);
+  Assert.ok(eventItem, `#${redoId} redos item creation`);
+
+  await calendar.deleteItem(eventItem.item);
+  clearTransactions();
+}
+
+/**
+ * Test the undo/redo functionality for event modification.
+ *
+ * @param {string} undoId - The id of the "undo" menu item.
+ * @param {string} redoId - The id of the "redo" menu item.
+ */
+async function testModifyUndoRedoEvent(undoId, redoId) {
+  let undo = document.getElementById(undoId);
+  let redo = document.getElementById(redoId);
+  Assert.ok(await isDisabled(undo), `#${undoId} is disabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  let event = new CalEvent();
+  event.title = "Modifiable Event";
+  event.startDate = cal.dtz.now();
+  await calendar.addItem(event);
+  window.goToDate(event.startDate);
+
+  let eventItem;
+  await TestUtils.waitForCondition(() => {
+    eventItem = document.querySelector("calendar-month-day-box-item");
+    return eventItem;
+  }, "event not created in time");
+
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editItem(window, eventItem);
+  await CalendarTestUtils.items.setData(dialogWindow, iframeWindow, {
+    title: "Modified Event",
+  });
+  await CalendarTestUtils.items.saveAndCloseItemDialog(dialogWindow);
+
+  await TestUtils.waitForCondition(() => {
+    eventItem = document.querySelector("calendar-month-day-box-item");
+    return eventItem && eventItem.item.title == "Modified Event";
+  }, "event not modified in time");
+
+  Assert.ok(!(await isDisabled(undo)), `#${undoId} is enabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  // Test undo.
+  await clickItem(undo);
+  await TestUtils.waitForCondition(() => {
+    eventItem = document.querySelector("calendar-month-day-box-item");
+    return eventItem && eventItem.item.title == "Modifiable Event";
+  }, `#${undoId} did not un-modify event in time`);
+
+  Assert.equal(eventItem.item.title, "Modifiable Event", `#${undoId} reverses item modification`);
+
+  // Test redo.
+  await clickItem(redo);
+  await TestUtils.waitForCondition(() => {
+    eventItem = document.querySelector("calendar-month-day-box-item");
+    return eventItem && eventItem.item.title == "Modified Event";
+  }, `${redoId} did not re-modify item in time`);
+
+  Assert.equal(eventItem.item.title, "Modified Event", `#${redoId} redos item modification`);
+
+  clearTransactions();
+  await calendar.deleteItem(eventItem.item);
+}
+
+/**
+ * Test the undo/redo functionality for event deletion.
+ *
+ * @param {string} undoId - The id of the "undo" menu item.
+ * @param {string} redoId - The id of the "redo" menu item.
+ */
+async function testDeleteUndoRedo(undoId, redoId) {
+  let undo = document.getElementById(undoId);
+  let redo = document.getElementById(redoId);
+  Assert.ok(await isDisabled(undo), `#${undoId} is disabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  let event = new CalEvent();
+  event.title = "Deletable Event";
+  event.startDate = cal.dtz.now();
+  await calendar.addItem(event);
+  window.goToDate(event.startDate);
+
+  let eventItem;
+  await TestUtils.waitForCondition(() => {
+    eventItem = document.querySelector("calendar-month-day-box-item");
+    return eventItem;
+  }, "event not created in time");
+
+  EventUtils.synthesizeMouseAtCenter(eventItem, {});
+  EventUtils.synthesizeKey("VK_DELETE");
+
+  await TestUtils.waitForCondition(() => {
+    eventItem = document.querySelector("calendar-month-day-box-item");
+    return !eventItem;
+  }, "event not deleted in time");
+
+  Assert.ok(!(await isDisabled(undo)), `#${undoId} is enabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  // Test undo.
+  await clickItem(undo);
+  await TestUtils.waitForCondition(() => {
+    eventItem = document.querySelector("calendar-month-day-box-item");
+    return eventItem;
+  }, `#${undoId} did not add event in time`);
+  Assert.ok(eventItem, `#${undoId} reverses item deletion`);
+
+  // Test redo.
+  await clickItem(redo);
+  await TestUtils.waitForCondition(() => {
+    eventItem = document.querySelector("calendar-month-day-box-item");
+    return !eventItem;
+  }, "redo did not delete item in time");
+
+  Assert.ok(!eventItem, `#${redoId} redos item deletion`);
+  clearTransactions();
+}
+
+/**
+ * Ensure the menu bar is visible and navigate the calendar view to today.
+ */
+add_setup(async function () {
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  clearTransactions();
+  document.getElementById("toolbar-menubar").setAttribute("autohide", null);
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.dtz.now());
+});
+
+/**
+ * Tests the menu bar's undo/redo after adding an event.
+ */
+add_task(async function testMenuBarAddEventUndoRedo() {
+  return testAddUndoRedoEvent("menu_undo", "menu_redo");
+}).__skipMe = AppConstants.platform == "macosx"; // Can't click menu bar on Mac.
+
+/**
+ * Tests the menu bar's undo/redo after modifying an event.
+ */
+add_task(async function testMenuBarModifyEventUndoRedo() {
+  return testModifyUndoRedoEvent("menu_undo", "menu_redo");
+}).__skipMe = AppConstants.platform == "macosx"; // Can't click menu bar on Mac.
+
+/**
+ * Tests the menu bar's undo/redo after deleting an event.
+ */
+add_task(async function testMenuBarDeleteEventUndoRedo() {
+  return testDeleteUndoRedo("menu_undo", "menu_redo");
+}).__skipMe = AppConstants.platform == "macosx"; // Can't click menu bar on Mac.
diff --git a/comm/calendar/test/browser/browser_import.js b/comm/calendar/test/browser/browser_import.js
new file mode 100644
index 0000000000..86e605802b
--- /dev/null
+++ b/comm/calendar/test/browser/browser_import.js
@@ -0,0 +1,285 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, you can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// This tests importing an ICS file. Rather than using the UI to trigger the
+// import, loadEventsFromFile is called directly.
+
+/* globals loadEventsFromFile */
+
+const { MockFilePicker } = ChromeUtils.importESModule(
+  "resource://testing-common/MockFilePicker.sys.mjs"
+);
+const ChromeRegistry = Cc["@mozilla.org/chrome/chrome-registry;1"].getService(Ci.nsIChromeRegistry);
+
+add_task(async () => {
+  await CalendarTestUtils.setCalendarView(window, "month");
+  await CalendarTestUtils.goToDate(window, 2019, 1, 1);
+
+  let chromeUrl = Services.io.newURI(getRootDirectory(gTestPath) + "data/import.ics");
+  let fileUrl = ChromeRegistry.convertChromeURL(chromeUrl);
+  let file = fileUrl.QueryInterface(Ci.nsIFileURL).file;
+
+  MockFilePicker.init(window);
+  MockFilePicker.setFiles([file]);
+  MockFilePicker.returnValue = MockFilePicker.returnCancel;
+
+  let calendar = CalendarTestUtils.createCalendar();
+
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+    MockFilePicker.cleanup();
+  });
+
+  let cancelReturn = await loadEventsFromFile();
+  ok(!cancelReturn, "loadEventsFromFile returns false on cancel");
+
+  // Prepare to test the import dialog.
+  MockFilePicker.returnValue = MockFilePicker.returnOK;
+
+  let dialogWindowPromise = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-ics-file-dialog.xhtml",
+    {
+      async callback(dialogWindow) {
+        let doc = dialogWindow.document;
+        let dialogElement = doc.querySelector("dialog");
+
+        let optionsPane = doc.getElementById("calendar-ics-file-dialog-options-pane");
+        let progressPane = doc.getElementById("calendar-ics-file-dialog-progress-pane");
+        let resultPane = doc.getElementById("calendar-ics-file-dialog-result-pane");
+
+        ok(!optionsPane.hidden);
+        ok(progressPane.hidden);
+        ok(resultPane.hidden);
+
+        // Check the initial import dialog state.
+        let displayedPath = doc.querySelector("#calendar-ics-file-dialog-file-path").value;
+        let pathFragment = "browser/comm/calendar/test/browser/data/import.ics";
+        if (Services.appinfo.OS == "WINNT") {
+          pathFragment = pathFragment.replace(/\//g, "\\");
+        }
+        is(
+          displayedPath.substring(displayedPath.length - pathFragment.length),
+          pathFragment,
+          "the displayed ics file path is correct"
+        );
+
+        let calendarMenu = doc.querySelector("#calendar-ics-file-dialog-calendar-menu");
+        // 0 is the Home calendar.
+        calendarMenu.selectedIndex = 1;
+        let calendarMenuItems = calendarMenu.querySelectorAll("menuitem");
+        is(calendarMenu.value, "Test", "correct calendar name is selected");
+        Assert.equal(calendarMenuItems.length, 1, "exactly one calendar is in the calendars menu");
+        is(calendarMenuItems[0].selected, true, "calendar menu item is selected");
+
+        let items;
+        await TestUtils.waitForCondition(() => {
+          items = doc.querySelectorAll(".calendar-ics-file-dialog-item-frame");
+          return items.length == 4;
+        }, "four calendar items are displayed");
+        is(
+          items[0].querySelector(".item-title").textContent,
+          "Event One",
+          "event 1 title should be correct"
+        );
+        is(
+          items[1].querySelector(".item-title").textContent,
+          "Event Two",
+          "event 2 title should be correct"
+        );
+        is(
+          items[2].querySelector(".item-title").textContent,
+          "Event Three",
+          "event 3 title should be correct"
+        );
+        is(
+          items[3].querySelector(".item-title").textContent,
+          "Event Four",
+          "event 4 title should be correct"
+        );
+        is(
+          items[0].querySelector(".item-date-row-start-date").textContent,
+          cal.dtz.formatter.formatDateTime(cal.createDateTime("20190101T150000")),
+          "event 1 start date should be correct"
+        );
+        is(
+          items[0].querySelector(".item-date-row-end-date").textContent,
+          cal.dtz.formatter.formatDateTime(cal.createDateTime("20190101T160000")),
+          "event 1 end date should be correct"
+        );
+        is(
+          items[1].querySelector(".item-date-row-start-date").textContent,
+          cal.dtz.formatter.formatDateTime(cal.createDateTime("20190101T160000")),
+          "event 2 start date should be correct"
+        );
+        is(
+          items[1].querySelector(".item-date-row-end-date").textContent,
+          cal.dtz.formatter.formatDateTime(cal.createDateTime("20190101T170000")),
+          "event 2 end date should be correct"
+        );
+        is(
+          items[2].querySelector(".item-date-row-start-date").textContent,
+          cal.dtz.formatter.formatDateTime(cal.createDateTime("20190101T170000")),
+          "event 3 start date should be correct"
+        );
+        is(
+          items[2].querySelector(".item-date-row-end-date").textContent,
+          cal.dtz.formatter.formatDateTime(cal.createDateTime("20190101T180000")),
+          "event 3 end date should be correct"
+        );
+        is(
+          items[3].querySelector(".item-date-row-start-date").textContent,
+          cal.dtz.formatter.formatDateTime(cal.createDateTime("20190101T180000")),
+          "event 4 start date should be correct"
+        );
+        is(
+          items[3].querySelector(".item-date-row-end-date").textContent,
+          cal.dtz.formatter.formatDateTime(cal.createDateTime("20190101T190000")),
+          "event 4 end date should be correct"
+        );
+
+        function check_displayed_titles(expectedTitles) {
+          let items = doc.querySelectorAll(
+            ".calendar-ics-file-dialog-item-frame:not([hidden]) > calendar-item-summary"
+          );
+          Assert.deepEqual(
+            [...items].map(summary => summary.item.title),
+            expectedTitles
+          );
+        }
+
+        let filterInput = doc.getElementById("calendar-ics-file-dialog-search-input");
+        async function check_filter(filterText, expectedTitles) {
+          let commandPromise = BrowserTestUtils.waitForEvent(filterInput, "command");
+
+          EventUtils.synthesizeMouseAtCenter(filterInput, {}, dialogWindow);
+          if (filterText) {
+            EventUtils.synthesizeKey("a", { accelKey: true }, dialogWindow);
+            EventUtils.sendString(filterText, dialogWindow);
+          } else {
+            EventUtils.synthesizeKey("VK_ESCAPE", {}, dialogWindow);
+          }
+
+          await commandPromise;
+
+          check_displayed_titles(expectedTitles);
+        }
+
+        await check_filter("event", ["Event One", "Event Two", "Event Three", "Event Four"]);
+        await check_filter("four", ["Event Four"]);
+        await check_filter("ONE", ["Event One"]);
+        await check_filter(`"event t"`, ["Event Two", "Event Three"]);
+        await check_filter("", ["Event One", "Event Two", "Event Three", "Event Four"]);
+
+        async function check_sort(order, expectedTitles) {
+          let sortButton = doc.getElementById("calendar-ics-file-dialog-sort-button");
+          let shownPromise = BrowserTestUtils.waitForEvent(sortButton, "popupshown");
+          EventUtils.synthesizeMouseAtCenter(sortButton, {}, dialogWindow);
+          await shownPromise;
+          let hiddenPromise = BrowserTestUtils.waitForEvent(sortButton, "popuphidden");
+          EventUtils.synthesizeMouseAtCenter(
+            doc.getElementById(`calendar-ics-file-dialog-sort-${order}`),
+            {},
+            dialogWindow
+          );
+          await hiddenPromise;
+
+          let items = doc.querySelectorAll("calendar-item-summary");
+          is(items.length, 4, "four calendar items are displayed");
+          Assert.deepEqual(
+            [...items].map(summary => summary.item.title),
+            expectedTitles
+          );
+        }
+
+        await check_sort("title-ascending", [
+          "Event Four",
+          "Event One",
+          "Event Three",
+          "Event Two",
+        ]);
+        await check_sort("start-descending", [
+          "Event Four",
+          "Event Three",
+          "Event Two",
+          "Event One",
+        ]);
+        await check_sort("title-descending", [
+          "Event Two",
+          "Event Three",
+          "Event One",
+          "Event Four",
+        ]);
+        await check_sort("start-ascending", [
+          "Event One",
+          "Event Two",
+          "Event Three",
+          "Event Four",
+        ]);
+
+        items = doc.querySelectorAll(".calendar-ics-file-dialog-item-frame");
+
+        // Import just the first item, and check that the correct number of items remains.
+        let firstItemImportButton = items[0].querySelector(
+          ".calendar-ics-file-dialog-item-import-button"
+        );
+        EventUtils.synthesizeMouseAtCenter(firstItemImportButton, { clickCount: 1 }, dialogWindow);
+
+        await TestUtils.waitForCondition(() => {
+          let remainingItems = doc.querySelectorAll(".calendar-ics-file-dialog-item-frame");
+          return remainingItems.length == 3;
+        }, "three items remain after importing the first item");
+        check_displayed_titles(["Event Two", "Event Three", "Event Four"]);
+
+        // Filter and import the shown items.
+        await check_filter("four", ["Event Four"]);
+
+        dialogElement.getButton("accept").click();
+        ok(optionsPane.hidden);
+        ok(!progressPane.hidden);
+        ok(resultPane.hidden);
+
+        await TestUtils.waitForCondition(() => !optionsPane.hidden);
+        ok(progressPane.hidden);
+        ok(resultPane.hidden);
+
+        is(filterInput.value, "");
+        check_displayed_titles(["Event Two", "Event Three"]);
+
+        // Click the accept button to import the remaining items.
+        dialogElement.getButton("accept").click();
+        ok(optionsPane.hidden);
+        ok(!progressPane.hidden);
+        ok(resultPane.hidden);
+
+        await TestUtils.waitForCondition(() => !resultPane.hidden);
+        ok(optionsPane.hidden);
+        ok(progressPane.hidden);
+
+        let messageElement = doc.querySelector("#calendar-ics-file-dialog-result-message");
+        is(messageElement.textContent, "Import complete.", "import success message appeared");
+
+        dialogElement.getButton("accept").click();
+      },
+    }
+  );
+
+  await loadEventsFromFile();
+  await dialogWindowPromise;
+
+  // Check that the items were actually successfully imported.
+  let result = await calendar.getItemsAsArray(
+    Ci.calICalendar.ITEM_FILTER_ALL_ITEMS,
+    0,
+    cal.createDateTime("20190101T000000"),
+    cal.createDateTime("20190102T000000")
+  );
+  is(result.length, 4, "all items that were imported were in fact imported");
+
+  await CalendarTestUtils.monthView.waitForItemAt(window, 1, 3, 4);
+
+  for (let item of result) {
+    await calendar.deleteItem(item);
+  }
+});
diff --git a/comm/calendar/test/browser/browser_localICS.js b/comm/calendar/test/browser/browser_localICS.js
new file mode 100644
index 0000000000..43e0299937
--- /dev/null
+++ b/comm/calendar/test/browser/browser_localICS.js
@@ -0,0 +1,63 @@
+/* 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/. */
+
+/* globals createCalendarUsingDialog */
+
+var { saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+const HOUR = 8;
+
+// Unique name needed as deleting a calendar only unsubscribes from it and
+// if same file were used on next testrun then previously created event
+// would show up.
+var calendarName = String(Date.now());
+var calendarFile = Services.dirsvc.get("TmpD", Ci.nsIFile);
+calendarFile.append(calendarName + ".ics");
+
+add_task(async function testLocalICS() {
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await createCalendarUsingDialog(calendarName, { network: {} });
+
+  // Create new event.
+  let box = CalendarTestUtils.dayView.getHourBoxAt(window, HOUR);
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, box);
+  await setData(dialogWindow, iframeWindow, { title: calendarName, calendar: calendarName });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Assert presence in view.
+  await CalendarTestUtils.dayView.waitForEventBoxAt(window, 1);
+
+  // Verify in file.
+  let fstream = Cc["@mozilla.org/network/file-input-stream;1"].createInstance(
+    Ci.nsIFileInputStream
+  );
+  let cstream = Cc["@mozilla.org/intl/converter-input-stream;1"].createInstance(
+    Ci.nsIConverterInputStream
+  );
+
+  // Wait a moment until file is written.
+  await TestUtils.waitForCondition(() => calendarFile.exists());
+
+  // Read the calendar file and check for the summary.
+  fstream.init(calendarFile, -1, 0, 0);
+  cstream.init(fstream, "UTF-8", 0, 0);
+
+  let str = {};
+  cstream.readString(-1, str);
+  cstream.close();
+
+  Assert.ok(str.value.includes("SUMMARY:" + calendarName));
+});
+
+registerCleanupFunction(() => {
+  for (let calendar of cal.manager.getCalendars()) {
+    if (calendar.name == calendarName) {
+      cal.manager.removeCalendar(calendar);
+    }
+  }
+});
diff --git a/comm/calendar/test/browser/browser_tabs.js b/comm/calendar/test/browser/browser_tabs.js
new file mode 100644
index 0000000000..950b98a68c
--- /dev/null
+++ b/comm/calendar/test/browser/browser_tabs.js
@@ -0,0 +1,26 @@
+/* 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 () => {
+  // Test the calendar tab opens and closes.
+  await CalendarTestUtils.openCalendarTab(window);
+  await CalendarTestUtils.closeCalendarTab(window);
+
+  // Test the tasks tab opens and closes.
+  await openTasksTab();
+  await closeTasksTab();
+
+  // Test the calendar and tasks tabs at the same time.
+  await CalendarTestUtils.openCalendarTab(window);
+  await openTasksTab();
+  await CalendarTestUtils.closeCalendarTab(window);
+  await closeTasksTab();
+
+  // Test calendar view selection.
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.setCalendarView(window, "week");
+  await CalendarTestUtils.setCalendarView(window, "multiweek");
+  await CalendarTestUtils.setCalendarView(window, "month");
+  await CalendarTestUtils.closeCalendarTab(window);
+});
diff --git a/comm/calendar/test/browser/browser_taskDelete.js b/comm/calendar/test/browser/browser_taskDelete.js
new file mode 100644
index 0000000000..dcbf7ab057
--- /dev/null
+++ b/comm/calendar/test/browser/browser_taskDelete.js
@@ -0,0 +1,185 @@
+/* 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/. */
+
+/**
+ * Tests for deleting tasks in the task view.
+ */
+const { mailTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/MailTestUtils.jsm"
+);
+const { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalRecurrenceInfo: "resource:///modules/CalRecurrenceInfo.jsm",
+  CalTodo: "resource:///modules/CalTodo.jsm",
+});
+
+let calendar = CalendarTestUtils.createCalendar("Task Delete Test", "memory");
+registerCleanupFunction(() => CalendarTestUtils.removeCalendar(calendar));
+
+/**
+ * Test ensures its possible to delete a task in the task view. Creates two task
+ * and deletes one.
+ */
+add_task(async function testTaskDeletion() {
+  let task1 = new CalTodo();
+  task1.id = "1";
+  task1.title = "Task 1";
+  task1.entryDate = cal.createDateTime("20210126T000001Z");
+
+  let task2 = new CalTodo();
+  task2.id = "2";
+  task2.title = "Task 2";
+  task2.entryDate = cal.createDateTime("20210127T000001Z");
+
+  await calendar.addItem(task1);
+  await calendar.addItem(task2);
+  await openTasksTab();
+
+  let tree = document.querySelector("#calendar-task-tree");
+  let radio = document.querySelector("#opt_next7days_filter");
+  let waitForRefresh = BrowserTestUtils.waitForEvent(tree, "refresh");
+  EventUtils.synthesizeMouseAtCenter(radio, {});
+  tree.refresh();
+
+  await waitForRefresh;
+  Assert.equal(tree.view.rowCount, 2, "2 tasks are displayed");
+
+  mailTestUtils.treeClick(EventUtils, window, tree, 0, 1, { clickCount: 1 });
+  EventUtils.synthesizeKey("VK_DELETE");
+
+  // Try and trigger a reflow
+  tree.getBoundingClientRect();
+  tree.invalidate();
+  await new Promise(r => setTimeout(r));
+
+  await TestUtils.waitForCondition(() => {
+    tree = document.querySelector("#calendar-task-tree");
+    return tree.view.rowCount == 1;
+  }, `task view displays ${tree.view.rowCount} tasks instead of 1`);
+
+  let result = await calendar.getItem(task1.id);
+  Assert.ok(!result, "first task was deleted successfully");
+
+  result = await calendar.getItem(task2.id);
+  Assert.ok(result, "second task was not deleted");
+  await calendar.deleteItem(task2);
+  await closeTasksTab();
+});
+
+/**
+ * Test ensures it is possible to delete a recurring task from the task view.
+ * See bug 1688708.
+ */
+add_task(async function testRecurringTaskDeletion() {
+  let repeatTask = new CalTodo();
+  repeatTask.id = "1";
+  repeatTask.title = "Repeating Task";
+  repeatTask.entryDate = cal.createDateTime("20210125T000001Z");
+  repeatTask.recurrenceInfo = new CalRecurrenceInfo(repeatTask);
+  repeatTask.recurrenceInfo.appendRecurrenceItem(
+    cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=3")
+  );
+
+  let nonRepeatTask = new CalTodo();
+  nonRepeatTask.id = "2";
+  nonRepeatTask.title = "Non-Repeating Task";
+  nonRepeatTask.entryDate = cal.createDateTime("20210126T000001Z");
+
+  repeatTask = await calendar.addItem(repeatTask);
+  nonRepeatTask = await calendar.addItem(nonRepeatTask);
+
+  await openTasksTab();
+
+  let tree = document.querySelector("#calendar-task-tree");
+  let radio = document.querySelector("#opt_next7days_filter");
+  let waitForRefresh = BrowserTestUtils.waitForEvent(tree, "refresh");
+  EventUtils.synthesizeMouseAtCenter(radio, {});
+  tree.refresh();
+
+  await waitForRefresh;
+  Assert.equal(tree.view.rowCount, 4, "4 tasks are displayed");
+
+  // Delete a single occurrence.
+  let handleSingleDelete = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-occurrence-prompt.xhtml",
+    {
+      async callback(win) {
+        let dialog = win.document.querySelector("dialog");
+        let button = dialog.querySelector("#accept-occurrence-button");
+        EventUtils.synthesizeMouseAtCenter(button, {}, win);
+      },
+    }
+  );
+  mailTestUtils.treeClick(EventUtils, window, tree, 1, 1, { clickCount: 1 });
+  EventUtils.synthesizeKey("VK_DELETE");
+  await handleSingleDelete;
+
+  // Try and trigger a reflow
+  tree.getBoundingClientRect();
+  tree.invalidate();
+  await new Promise(r => setTimeout(r));
+
+  await TestUtils.waitForCondition(() => {
+    tree = document.querySelector("#calendar-task-tree");
+    return tree.view.rowCount == 3;
+  }, `task view displays ${tree.view.rowCount} tasks instead of 3`);
+
+  repeatTask = await calendar.getItem(repeatTask.id);
+
+  Assert.equal(
+    repeatTask.recurrenceInfo.getOccurrences(
+      cal.createDateTime("20210126T000001Z"),
+      cal.createDateTime("20210126T000001Z"),
+      10
+    ).length,
+    0,
+    "a single occurrence was deleted successfully"
+  );
+
+  Assert.equal(
+    repeatTask.recurrenceInfo.getOccurrences(
+      repeatTask.entryDate,
+      cal.createDateTime("20210131T000001Z"),
+      10
+    ).length,
+    2,
+    "other occurrences were not removed"
+  );
+
+  // Delete all occurrences
+  let handleAllDelete = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-occurrence-prompt.xhtml",
+    {
+      async callback(win) {
+        let dialog = win.document.querySelector("dialog");
+        let button = dialog.querySelector("#accept-parent-button");
+        EventUtils.synthesizeMouseAtCenter(button, {}, win);
+      },
+    }
+  );
+
+  mailTestUtils.treeClick(EventUtils, window, tree, 1, 1, { clickCount: 1 });
+  EventUtils.synthesizeKey("VK_DELETE");
+  await handleAllDelete;
+
+  // Try and trigger a reflow
+  tree.getBoundingClientRect();
+  tree.invalidate();
+  await new Promise(r => setTimeout(r));
+
+  await TestUtils.waitForCondition(() => {
+    tree = document.querySelector("#calendar-task-tree");
+    return tree.view.rowCount == 1;
+  }, `task view displays ${tree.view.rowCount} tasks instead of 1`);
+
+  repeatTask = await calendar.getItem(repeatTask.id);
+  Assert.ok(!repeatTask, "all occurrences were removed");
+
+  let result = await calendar.getItem(nonRepeatTask.id);
+  Assert.ok(result, "non-recurring task was not deleted");
+  await closeTasksTab();
+});
diff --git a/comm/calendar/test/browser/browser_taskDisplay.js b/comm/calendar/test/browser/browser_taskDisplay.js
new file mode 100644
index 0000000000..1ccd0dac3f
--- /dev/null
+++ b/comm/calendar/test/browser/browser_taskDisplay.js
@@ -0,0 +1,274 @@
+/* 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/. */
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalRecurrenceInfo: "resource:///modules/CalRecurrenceInfo.jsm",
+  CalTodo: "resource:///modules/CalTodo.jsm",
+});
+
+var calendar = CalendarTestUtils.createCalendar();
+registerCleanupFunction(() => {
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+let tree = document.getElementById("calendar-task-tree");
+
+add_task(async () => {
+  async function createTask(title, attributes = {}) {
+    let task = new CalTodo();
+    task.title = title;
+    for (let [key, value] of Object.entries(attributes)) {
+      task[key] = value;
+    }
+    return calendar.addItem(task);
+  }
+
+  function treeRefresh() {
+    return BrowserTestUtils.waitForEvent(tree, "refresh");
+  }
+
+  async function setFilterGroup(name) {
+    info(`Setting filter to ${name}`);
+    let radio = document.getElementById(`opt_${name}_filter`);
+    EventUtils.synthesizeMouseAtCenter(radio, {});
+    await treeRefresh();
+    Assert.equal(
+      document.getElementById("calendar-task-tree").getAttribute("filterValue"),
+      radio.value,
+      "Filter group changed"
+    );
+  }
+
+  async function setFilterText(text) {
+    EventUtils.synthesizeMouseAtCenter(document.getElementById("task-text-filter-field"), {});
+    EventUtils.sendString(text);
+    Assert.equal(document.getElementById("task-text-filter-field").value, text, "Filter text set");
+    await treeRefresh();
+  }
+
+  async function clearFilterText() {
+    EventUtils.synthesizeMouseAtCenter(document.getElementById("task-text-filter-field"), {});
+    EventUtils.synthesizeKey("VK_ESCAPE");
+    Assert.equal(
+      document.getElementById("task-text-filter-field").value,
+      "",
+      "Filter text cleared"
+    );
+    await treeRefresh();
+  }
+
+  async function checkVisibleTasks(...expectedTasks) {
+    function toPrettyString(task) {
+      if (task.recurrenceId) {
+        return `${task.title}#${task.recurrenceId}`;
+      }
+      return task.title;
+    }
+    tree.getBoundingClientRect(); // Try and trigger a reflow...
+    tree.invalidate();
+
+    // It seems that under certain conditions notifyOperationComplete() is
+    // called in CalStorageCalender.getItems before all the results have been
+    // retrieved. This results in the "refresh" event being fired prematurely in
+    // calendar-task-tree. After some investigation, the cause of this seems to
+    // be related to multiple calls of executeAsync() in CalStorageItemModel.
+    // getAdditionalDataForItemMap() not finishing before notifyOperationComplete()
+    // is called despite being awaited on.
+    // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+    await new Promise(r => setTimeout(r, 500));
+
+    let actualTasks = [];
+    for (let i = 0; i < tree.view.rowCount; i++) {
+      actualTasks.push(tree.getTaskAtRow(i));
+    }
+    info("Expected: " + expectedTasks.map(toPrettyString).join(", "));
+    info("Actual: " + actualTasks.map(toPrettyString).join(", "));
+
+    Assert.equal(tree.view.rowCount, expectedTasks.length, "Correct number of tasks");
+    await new Promise(r => setTimeout(r));
+
+    // Although the order of expectedTasks matches the observed behaviour when
+    // this test was written, order is NOT checked here. The order of the list
+    // is not well defined (particularly when changing the filter text).
+    for (let aTask of actualTasks) {
+      Assert.ok(
+        expectedTasks.some(eTask => eTask.hasSameIds(aTask)),
+        toPrettyString(aTask)
+      );
+    }
+  }
+
+  let today = cal.dtz.now();
+  today.hour = today.minute = today.second = 0;
+  let yesterday = today.clone();
+  yesterday.addDuration(cal.createDuration("-P1D"));
+  let tomorrow = today.clone();
+  tomorrow.addDuration(cal.createDuration("P1D"));
+  let later = today.clone();
+  later.addDuration(cal.createDuration("P2W"));
+
+  let tasks = {
+    incomplete: await createTask("Incomplete"),
+    started30: await createTask("30% started", { percentComplete: 30 }),
+    started60: await createTask("60% started", { percentComplete: 60 }),
+    complete: await createTask("Complete", { isCompleted: true }),
+    overdue: await createTask("Overdue", { dueDate: yesterday }),
+    startsToday: await createTask("Starts today", { entryDate: today }),
+    startsTomorrow: await createTask("Starts tomorrow", { entryDate: tomorrow }),
+    startsLater: await createTask("Starts later", { entryDate: later }),
+  };
+
+  let repeatingTask = new CalTodo();
+  repeatingTask.title = "Repeating";
+  repeatingTask.entryDate = yesterday;
+  repeatingTask.recurrenceInfo = new CalRecurrenceInfo(repeatingTask);
+  repeatingTask.recurrenceInfo.appendRecurrenceItem(
+    cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=3")
+  );
+
+  let firstOccurrence = repeatingTask.recurrenceInfo.getOccurrenceFor(yesterday);
+  firstOccurrence.isCompleted = true;
+  firstOccurrence.completedDate = yesterday;
+  repeatingTask.recurrenceInfo.modifyException(firstOccurrence, true);
+
+  repeatingTask = await calendar.addItem(repeatingTask);
+
+  let occurrences = repeatingTask.recurrenceInfo.getOccurrences(yesterday, later, 10);
+  Assert.equal(occurrences.length, 3);
+
+  await openTasksTab();
+
+  await setFilterGroup("all");
+  await checkVisibleTasks(
+    tasks.incomplete,
+    tasks.started30,
+    tasks.started60,
+    tasks.complete,
+    tasks.overdue,
+    tasks.startsToday,
+    tasks.startsTomorrow,
+    tasks.startsLater,
+    repeatingTask
+  );
+
+  await setFilterGroup("open");
+  await checkVisibleTasks(
+    tasks.incomplete,
+    tasks.started30,
+    tasks.started60,
+    tasks.overdue,
+    tasks.startsToday,
+    tasks.startsTomorrow,
+    tasks.startsLater,
+    occurrences[1],
+    occurrences[2]
+  );
+
+  await setFilterGroup("completed");
+  await checkVisibleTasks(tasks.complete, occurrences[0]);
+
+  await setFilterGroup("overdue");
+  await checkVisibleTasks(tasks.overdue);
+
+  await setFilterGroup("notstarted");
+  await checkVisibleTasks(tasks.overdue, tasks.incomplete, tasks.startsToday, occurrences[1]);
+
+  await setFilterGroup("next7days");
+  await checkVisibleTasks(
+    tasks.overdue,
+    tasks.incomplete,
+    tasks.startsToday,
+    tasks.started30,
+    tasks.started60,
+    tasks.complete,
+    tasks.startsTomorrow,
+    occurrences[1],
+    occurrences[2]
+  );
+
+  await setFilterGroup("today");
+  await checkVisibleTasks(
+    tasks.overdue,
+    tasks.incomplete,
+    tasks.startsToday,
+    tasks.started30,
+    tasks.started60,
+    tasks.complete,
+    occurrences[1]
+  );
+
+  await setFilterGroup("throughcurrent");
+  await checkVisibleTasks(
+    tasks.overdue,
+    tasks.incomplete,
+    tasks.startsToday,
+    tasks.started30,
+    tasks.started60,
+    tasks.complete,
+    occurrences[1]
+  );
+
+  await setFilterText("No matches");
+  await checkVisibleTasks();
+
+  await clearFilterText();
+  await checkVisibleTasks(
+    tasks.incomplete,
+    tasks.started30,
+    tasks.started60,
+    tasks.complete,
+    tasks.overdue,
+    tasks.startsToday,
+    occurrences[1]
+  );
+
+  await setFilterText("StArTeD");
+  await checkVisibleTasks(tasks.started30, tasks.started60);
+
+  await setFilterGroup("today");
+  Assert.equal(document.getElementById("task-text-filter-field").value, "StArTeD");
+  await checkVisibleTasks(tasks.started30, tasks.started60);
+
+  await setFilterGroup("next7days");
+  Assert.equal(document.getElementById("task-text-filter-field").value, "StArTeD");
+  await checkVisibleTasks(tasks.started30, tasks.started60);
+
+  await setFilterGroup("notstarted");
+  Assert.equal(document.getElementById("task-text-filter-field").value, "StArTeD");
+  await checkVisibleTasks();
+
+  await setFilterGroup("overdue");
+  Assert.equal(document.getElementById("task-text-filter-field").value, "StArTeD");
+  await checkVisibleTasks();
+
+  await setFilterGroup("completed");
+  Assert.equal(document.getElementById("task-text-filter-field").value, "StArTeD");
+  await checkVisibleTasks();
+
+  await setFilterGroup("open");
+  Assert.equal(document.getElementById("task-text-filter-field").value, "StArTeD");
+  await checkVisibleTasks(tasks.started30, tasks.started60);
+
+  await setFilterGroup("all");
+  Assert.equal(document.getElementById("task-text-filter-field").value, "StArTeD");
+  await checkVisibleTasks(tasks.started30, tasks.started60);
+
+  await clearFilterText();
+  await checkVisibleTasks(
+    tasks.started30,
+    tasks.started60,
+    tasks.incomplete,
+    tasks.complete,
+    tasks.overdue,
+    tasks.startsToday,
+    tasks.startsTomorrow,
+    tasks.startsLater,
+    repeatingTask
+  );
+
+  for (let task of Object.values(tasks)) {
+    await calendar.deleteItem(task);
+  }
+  await setFilterGroup("throughcurrent");
+});
diff --git a/comm/calendar/test/browser/browser_taskUndoRedo.js b/comm/calendar/test/browser/browser_taskUndoRedo.js
new file mode 100644
index 0000000000..09cf9a8de2
--- /dev/null
+++ b/comm/calendar/test/browser/browser_taskUndoRedo.js
@@ -0,0 +1,244 @@
+/* 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/. */
+
+"use strict";
+
+/**
+ * Tests for ensuring the undo/redo options are enabled properly when
+ * manipulating tasks.
+ */
+
+var { mailTestUtils } = ChromeUtils.import("resource://testing-common/mailnews/MailTestUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalTodo: "resource:///modules/CalTodo.jsm",
+  CalTransactionManager: "resource:///modules/CalTransactionManager.jsm",
+});
+
+const calendar = CalendarTestUtils.createCalendar("Undo Redo Test", "memory");
+const calTransManager = CalTransactionManager.getInstance();
+
+/**
+ * Checks the value of the "disabled" property for items in either the "Edit"
+ * menu bar or the app menu. Display of the relevant menu is triggered first so
+ * the UI code can update the respective items.
+ *
+ * @param {XULElement} element - The menu item we want to check, if its id begins
+ *                               with "menu" then we assume it is in the menu
+ *                               bar, if "appmenu" then the app menu.
+ */
+async function isDisabled(element) {
+  let targetMenu = document.getElementById("menu_EditPopup");
+
+  let shownPromise = BrowserTestUtils.waitForEvent(targetMenu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("menu_Edit"), {});
+  await shownPromise;
+
+  let hiddenPromise = BrowserTestUtils.waitForEvent(targetMenu, "popuphidden");
+  let status = element.disabled;
+  EventUtils.synthesizeKey("VK_ESCAPE");
+  await hiddenPromise;
+  return status;
+}
+
+/**
+ * Removes CalTransaction items from the CalTransactionManager stacks so other
+ * tests are unhindered.
+ */
+function clearTransactions() {
+  calTransManager.undoStack = [];
+  calTransManager.redoStack = [];
+}
+
+/**
+ * Test the undo/redo functionality for task creation.
+ *
+ * @param {string} undoId - The id of the "undo" menu item.
+ * @param {string} redoId - The id of the "redo" menu item.
+ */
+async function taskAddUndoRedoTask(undoId, redoId) {
+  let undo = document.getElementById(undoId);
+  let redo = document.getElementById(redoId);
+  Assert.ok(await isDisabled(undo), `#${undoId} is disabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  let newBtn = document.getElementById("sidePanelNewTask");
+  let windowPromise = CalendarTestUtils.waitForEventDialog("edit");
+  EventUtils.synthesizeMouseAtCenter(newBtn, {});
+
+  let win = await windowPromise;
+  let iframeWin = win.document.getElementById("calendar-item-panel-iframe").contentWindow;
+  await CalendarTestUtils.items.setData(win, iframeWin, { title: "New Task" });
+  await CalendarTestUtils.items.saveAndCloseItemDialog(win);
+
+  let tree = document.querySelector("#calendar-task-tree");
+  let refreshPromise = BrowserTestUtils.waitForEvent(tree, "refresh");
+  tree.refresh();
+  await refreshPromise;
+
+  Assert.equal(tree.view.rowCount, 1);
+  Assert.ok(!(await isDisabled(undo)), `#${undoId} is enabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  // Test undo.
+  undo.doCommand();
+  await TestUtils.waitForCondition(
+    () => tree.view.rowCount == 0,
+    `${undoId} did not remove task in time`
+  );
+  Assert.equal(tree.view.rowCount, 0, `#${undoId} reverses task creation`);
+
+  // Test redo.
+  redo.doCommand();
+  await TestUtils.waitForCondition(
+    () => tree.view.rowCount == 1,
+    `${redoId} did not re-create task in time`
+  );
+
+  let task = tree.getTaskAtRow(0);
+  Assert.equal(task.title, "New Task", `#${redoId} redos task creation`);
+  await calendar.deleteItem(task);
+  clearTransactions();
+}
+
+/**
+ * Test the undo/redo functionality for task modification.
+ *
+ * @param {string} undoId - The id of the "undo" menu item.
+ * @param {string} redoId - The id of the "redo" menu item.
+ */
+async function testModifyUndoRedoTask(undoId, redoId) {
+  let undo = document.getElementById(undoId);
+  let redo = document.getElementById(redoId);
+  Assert.ok(await isDisabled(undo), `#${undoId} is disabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  let task = new CalTodo();
+  task.title = "Modifiable Task";
+  task.entryDate = cal.dtz.now();
+  await calendar.addItem(task);
+
+  let tree = document.querySelector("#calendar-task-tree");
+  let refreshPromise = BrowserTestUtils.waitForEvent(tree, "refresh");
+  tree.refresh();
+  await refreshPromise;
+
+  let windowPromise = CalendarTestUtils.waitForEventDialog("edit");
+  mailTestUtils.treeClick(EventUtils, window, tree, 0, 1, { clickCount: 2 });
+
+  let win = await windowPromise;
+  let iframeWin = win.document.getElementById("calendar-item-panel-iframe").contentWindow;
+  await CalendarTestUtils.items.setData(win, iframeWin, { title: "Modified Task" });
+  await CalendarTestUtils.items.saveAndCloseItemDialog(win);
+
+  Assert.equal(tree.getTaskAtRow(0).title, "Modified Task");
+  Assert.ok(!(await isDisabled(undo)), `#${undoId} is enabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  // Test undo.
+  undo.doCommand();
+  refreshPromise = BrowserTestUtils.waitForEvent(tree, "refresh");
+  tree.refresh();
+  await refreshPromise;
+  Assert.equal(
+    tree.getTaskAtRow(0).title,
+    "Modifiable Task",
+    `#${undoId} reverses task modification`
+  );
+
+  // Test redo.
+  redo.doCommand();
+  refreshPromise = BrowserTestUtils.waitForEvent(tree, "refresh");
+  tree.refresh();
+  await refreshPromise;
+  Assert.equal(tree.getTaskAtRow(0).title, "Modified Task", `#${redoId} redos task modification`);
+
+  clearTransactions();
+  await calendar.deleteItem(tree.getTaskAtRow(0));
+}
+
+/**
+ * Test the undo/redo functionality for task deletion.
+ *
+ * @param {string} undoId - The id of the "undo" menu item.
+ * @param {string} redoId - The id of the "redo" menu item.
+ */
+async function testDeleteUndoRedoTask(undoId, redoId) {
+  let undo = document.getElementById(undoId);
+  let redo = document.getElementById(redoId);
+  Assert.ok(await isDisabled(undo), `#${undoId} is disabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  let task = new CalTodo();
+  task.title = "Deletable Task";
+  task.startDate = cal.dtz.now();
+  task.entryDate = cal.dtz.now();
+  await calendar.addItem(task);
+
+  let tree = document.querySelector("#calendar-task-tree");
+  let refreshPromise = BrowserTestUtils.waitForEvent(tree, "refresh");
+  tree.refresh();
+  await refreshPromise;
+  Assert.equal(tree.view.rowCount, 1);
+
+  mailTestUtils.treeClick(EventUtils, window, tree, 0, 1, { clickCount: 1 });
+  EventUtils.synthesizeKey("VK_DELETE");
+  await TestUtils.waitForCondition(() => tree.view.rowCount == 0, "task was not removed in time");
+
+  Assert.ok(!(await isDisabled(undo)), `#${undoId} is enabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  // Test undo.
+  undo.doCommand();
+  tree.refresh();
+  await TestUtils.waitForCondition(
+    () => tree.view.rowCount == 1,
+    "undo did not restore task in time"
+  );
+  Assert.equal(tree.getTaskAtRow(0).title, "Deletable Task", `#${undoId} reverses item deletion`);
+
+  // Test redo.
+  redo.doCommand();
+  await TestUtils.waitForCondition(
+    () => tree.view.rowCount == 0,
+    `#${redoId} redo did not delete item in time`
+  );
+  Assert.ok(!tree.getTaskAtRow(0), `#${redoId} redos item deletion`);
+
+  clearTransactions();
+}
+
+/**
+ * Ensure the menu bar is visible and navigate to the task view.
+ */
+add_setup(async function () {
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  clearTransactions();
+  document.getElementById("toolbar-menubar").setAttribute("autohide", null);
+  await openTasksTab();
+});
+
+/**
+ * Tests the menu bar's undo/redo after adding an event.
+ */
+add_task(async function testMenuBarAddTaskUndoRedo() {
+  return taskAddUndoRedoTask("menu_undo", "menu_redo");
+}).__skipMe = AppConstants.platform == "macosx"; // Can't click menu bar on Mac.
+
+/**
+ * Tests the menu bar's undo/redo after modifying an event.
+ */
+add_task(async function testMenuBarModifyTaskUndoRedo() {
+  return testModifyUndoRedoTask("menu_undo", "menu_redo");
+}).__skipMe = AppConstants.platform == "macosx"; // Can't click menu bar on Mac.
+
+/**
+ * Tests the menu bar's undo/redo after deleting an event.
+ */
+add_task(async function testMenuBarDeleteTaskUndoRedo() {
+  return testDeleteUndoRedoTask("menu_undo", "menu_redo");
+}).__skipMe = AppConstants.platform == "macosx"; // Can't click menu bar on Mac.
diff --git a/comm/calendar/test/browser/browser_todayPane.js b/comm/calendar/test/browser/browser_todayPane.js
new file mode 100644
index 0000000000..8ad9141815
--- /dev/null
+++ b/comm/calendar/test/browser/browser_todayPane.js
@@ -0,0 +1,820 @@
+/* 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/. */
+
+/* globals TodayPane */
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { formatDate, formatTime } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalDateTime: "resource:///modules/CalDateTime.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalRecurrenceInfo: "resource:///modules/CalRecurrenceInfo.jsm",
+});
+
+let calendar = CalendarTestUtils.createCalendar();
+Services.prefs.setIntPref("calendar.agenda.days", 7);
+registerCleanupFunction(() => {
+  CalendarTestUtils.removeCalendar(calendar);
+  Services.prefs.clearUserPref("calendar.agenda.days");
+});
+
+let today = cal.dtz.now();
+let startHour = today.hour;
+today.hour = today.minute = today.second = 0;
+
+let todayPanePanel = document.getElementById("today-pane-panel");
+let todayPaneStatusButton = document.getElementById("calendar-status-todaypane-button");
+
+// Go to mail tab.
+selectFolderTab();
+
+// Verify today pane open.
+if (todayPanePanel.hasAttribute("collapsed")) {
+  EventUtils.synthesizeMouseAtCenter(todayPaneStatusButton, {});
+}
+Assert.ok(!todayPanePanel.hasAttribute("collapsed"), "Today Pane is open");
+
+// Verify today pane's date.
+Assert.equal(document.getElementById("datevalue-label").value, today.day, "Today Pane shows today");
+
+async function addEvent(title, relativeStart, relativeEnd, isAllDay) {
+  let event = new CalEvent();
+  event.id = cal.getUUID();
+  event.title = title;
+  event.startDate = today.clone();
+  event.startDate.addDuration(cal.createDuration(relativeStart));
+  event.startDate.isDate = isAllDay;
+  event.endDate = today.clone();
+  event.endDate.addDuration(cal.createDuration(relativeEnd));
+  event.endDate.isDate = isAllDay;
+  return calendar.addItem(event);
+}
+
+function checkEvent(row, { dateHeader, time, title, relative, overlap, classes = [] }) {
+  let dateHeaderElement = row.querySelector(".agenda-date-header");
+  if (dateHeader) {
+    Assert.ok(BrowserTestUtils.is_visible(dateHeaderElement), "date header is visible");
+    if (dateHeader instanceof CalDateTime || dateHeader instanceof Ci.calIDateTime) {
+      dateHeader = cal.dtz.formatter.formatDateLongWithoutYear(dateHeader);
+    }
+    Assert.equal(dateHeaderElement.textContent, dateHeader, "date header has correct value");
+  } else {
+    Assert.ok(BrowserTestUtils.is_hidden(dateHeaderElement), "date header is hidden");
+  }
+
+  let calendarElement = row.querySelector(".agenda-listitem-calendar");
+  let timeElement = row.querySelector(".agenda-listitem-time");
+  if (time) {
+    Assert.ok(BrowserTestUtils.is_visible(calendarElement), "calendar is visible");
+    Assert.ok(BrowserTestUtils.is_visible(timeElement), "time is visible");
+    if (time instanceof CalDateTime || time instanceof Ci.calIDateTime) {
+      time = cal.dtz.formatter.formatTime(time);
+    }
+    Assert.equal(timeElement.textContent, time, "time has correct value");
+  } else if (time === "") {
+    Assert.ok(BrowserTestUtils.is_visible(calendarElement), "calendar is visible");
+    Assert.ok(BrowserTestUtils.is_hidden(timeElement), "time is hidden");
+  } else {
+    Assert.ok(BrowserTestUtils.is_hidden(calendarElement), "calendar is hidden");
+    Assert.ok(BrowserTestUtils.is_hidden(timeElement), "time is hidden");
+  }
+
+  let titleElement = row.querySelector(".agenda-listitem-title");
+  Assert.ok(BrowserTestUtils.is_visible(titleElement), "title is visible");
+  Assert.equal(titleElement.textContent, title, "title has correct value");
+
+  let relativeElement = row.querySelector(".agenda-listitem-relative");
+  if (Array.isArray(relative)) {
+    Assert.ok(BrowserTestUtils.is_visible(relativeElement), "relative time is visible");
+    Assert.report(
+      !relative.includes(relativeElement.textContent),
+      relative,
+      relativeElement.textContent,
+      "relative time is correct",
+      "includes"
+    );
+  } else if (relative !== undefined) {
+    Assert.ok(BrowserTestUtils.is_hidden(relativeElement), "relative time is hidden");
+  }
+
+  let overlapElement = row.querySelector(".agenda-listitem-overlap");
+  if (overlap) {
+    Assert.ok(BrowserTestUtils.is_visible(overlapElement), "overlap is visible");
+    Assert.equal(
+      overlapElement.src,
+      `chrome://messenger/skin/icons/new/event-${overlap}.svg`,
+      "overlap has correct image"
+    );
+    Assert.equal(
+      overlapElement.dataset.l10nId,
+      `calendar-editable-item-multiday-event-icon-${overlap}`,
+      "overlap has correct alt text"
+    );
+  } else {
+    Assert.ok(BrowserTestUtils.is_hidden(overlapElement), "overlap is hidden");
+  }
+
+  for (let className of classes) {
+    Assert.ok(row.classList.contains(className), `row has ${className} class`);
+  }
+}
+
+function checkEvents(...expectedEvents) {
+  Assert.equal(TodayPane.agenda.rowCount, expectedEvents.length, "expected number of rows shown");
+  for (let i = 0; i < expectedEvents.length; i++) {
+    Assert.ok(TodayPane.agenda.rows[i].getAttribute("is"), "agenda-listitem");
+    checkEvent(TodayPane.agenda.rows[i], expectedEvents[i]);
+  }
+}
+
+add_task(async function testBasicAllDay() {
+  let todaysEvent = await addEvent("Today's Event", "P0D", "P1D", true);
+  checkEvents({ dateHeader: "Today", title: "Today's Event" });
+
+  let tomorrowsEvent = await addEvent("Tomorrow's Event", "P1D", "P2D", true);
+  checkEvents(
+    { dateHeader: "Today", title: "Today's Event" },
+    { dateHeader: "Tomorrow", title: "Tomorrow's Event" }
+  );
+
+  let events = [];
+  for (let i = 2; i < 7; i++) {
+    events.push(await addEvent(`Event ${i + 1}`, `P${i}D`, `P${i + 1}D`, true));
+    checkEvents(
+      { dateHeader: "Today", title: "Today's Event" },
+      { dateHeader: "Tomorrow", title: "Tomorrow's Event" },
+      ...events.map(e => {
+        return { dateHeader: e.startDate, title: e.title };
+      })
+    );
+  }
+
+  await calendar.deleteItem(todaysEvent);
+  checkEvents(
+    { dateHeader: "Tomorrow", title: "Tomorrow's Event" },
+    ...events.map(e => {
+      return { dateHeader: e.startDate, title: e.title };
+    })
+  );
+  await calendar.deleteItem(tomorrowsEvent);
+  checkEvents(
+    ...events.map(e => {
+      return { dateHeader: e.startDate, title: e.title };
+    })
+  );
+
+  while (events.length) {
+    await calendar.deleteItem(events.shift());
+    checkEvents(
+      ...events.map(e => {
+        return { dateHeader: e.startDate, title: e.title };
+      })
+    );
+  }
+});
+
+add_task(async function testBasic() {
+  let time = today.clone();
+  time.hour = 23;
+
+  let todaysEvent = await addEvent("Today's Event", "P0DT23H", "P1D");
+  checkEvents({ dateHeader: "Today", time, title: "Today's Event" });
+
+  let tomorrowsEvent = await addEvent("Tomorrow's Event", "P1DT23H", "P2D");
+  checkEvents(
+    { dateHeader: "Today", time, title: "Today's Event" },
+    { dateHeader: "Tomorrow", time, title: "Tomorrow's Event" }
+  );
+
+  let events = [];
+  for (let i = 2; i < 7; i++) {
+    events.push(await addEvent(`Event ${i + 1}`, `P${i}DT23H`, `P${i + 1}D`));
+    checkEvents(
+      { dateHeader: "Today", time, title: "Today's Event" },
+      { dateHeader: "Tomorrow", time, title: "Tomorrow's Event" },
+      ...events.map(e => {
+        return { dateHeader: e.startDate, time, title: e.title };
+      })
+    );
+  }
+
+  await calendar.deleteItem(todaysEvent);
+  checkEvents(
+    { dateHeader: "Tomorrow", time, title: "Tomorrow's Event" },
+    ...events.map(e => {
+      return { dateHeader: e.startDate, time, title: e.title };
+    })
+  );
+  await calendar.deleteItem(tomorrowsEvent);
+  checkEvents(
+    ...events.map(e => {
+      return { dateHeader: e.startDate, time, title: e.title };
+    })
+  );
+
+  while (events.length) {
+    await calendar.deleteItem(events.shift());
+    checkEvents(
+      ...events.map(e => {
+        return { dateHeader: e.startDate, time, title: e.title };
+      })
+    );
+  }
+});
+
+/**
+ * Adds and removes events in a different order from which they occur.
+ * This checks that the events are inserted in the right place, and that the
+ * date header is shown/hidden appropriately.
+ */
+add_task(async function testSortOrder() {
+  let afternoonEvent = await addEvent("Afternoon Event", "P1DT13H", "P1DT17H");
+  checkEvents({
+    dateHeader: "Tomorrow",
+    time: afternoonEvent.startDate,
+    title: "Afternoon Event",
+  });
+
+  let morningEvent = await addEvent("Morning Event", "P1DT8H", "P1DT12H");
+  checkEvents(
+    { dateHeader: "Tomorrow", time: morningEvent.startDate, title: "Morning Event" },
+    { time: afternoonEvent.startDate, title: "Afternoon Event" }
+  );
+
+  let allDayEvent = await addEvent("All Day Event", "P1D", "P2D", true);
+  checkEvents(
+    { dateHeader: "Tomorrow", title: "All Day Event" },
+    { time: morningEvent.startDate, title: "Morning Event" },
+    { time: afternoonEvent.startDate, title: "Afternoon Event" }
+  );
+
+  let eveningEvent = await addEvent("Evening Event", "P1DT18H", "P1DT22H");
+  checkEvents(
+    { dateHeader: "Tomorrow", title: "All Day Event" },
+    { time: morningEvent.startDate, title: "Morning Event" },
+    { time: afternoonEvent.startDate, title: "Afternoon Event" },
+    { time: eveningEvent.startDate, title: "Evening Event" }
+  );
+
+  await calendar.deleteItem(afternoonEvent);
+  checkEvents(
+    { dateHeader: "Tomorrow", title: "All Day Event" },
+    { time: morningEvent.startDate, title: "Morning Event" },
+    { time: eveningEvent.startDate, title: "Evening Event" }
+  );
+
+  await calendar.deleteItem(morningEvent);
+  checkEvents(
+    { dateHeader: "Tomorrow", title: "All Day Event" },
+    { time: eveningEvent.startDate, title: "Evening Event" }
+  );
+
+  await calendar.deleteItem(allDayEvent);
+  checkEvents({
+    dateHeader: "Tomorrow",
+    time: eveningEvent.startDate,
+    title: "Evening Event",
+  });
+
+  await calendar.deleteItem(eveningEvent);
+  checkEvents();
+});
+
+/**
+ * Check events that begin and end on different days inside the date range.
+ * All-day events are still sorted ahead of non-all-day events.
+ */
+add_task(async function testOverlapInside() {
+  let allDayEvent = await addEvent("All Day Event", "P0D", "P2D", true);
+  checkEvents(
+    { dateHeader: "Today", title: "All Day Event", overlap: "start" },
+    { dateHeader: "Tomorrow", title: "All Day Event", overlap: "end" }
+  );
+
+  let timedEvent = await addEvent("Timed Event", "P1H", "P1D23H");
+  checkEvents(
+    { dateHeader: "Today", title: "All Day Event", overlap: "start" },
+    { time: timedEvent.startDate, title: "Timed Event", overlap: "start" },
+    { dateHeader: "Tomorrow", title: "All Day Event", overlap: "end" },
+    { time: timedEvent.endDate, title: "Timed Event", overlap: "end" }
+  );
+
+  await calendar.deleteItem(allDayEvent);
+  await calendar.deleteItem(timedEvent);
+});
+
+/**
+ * Check events that begin and end on different days and that end at midnight.
+ * The list item for the end of the event should be the last one on the day
+ * before the end midnight, and its time label should display "24:00".
+ */
+add_task(async function testOverlapEndAtMidnight() {
+  // Start with an event that begins outside the displayed dates.
+
+  let timedEvent = await addEvent("Timed Event", "-P1D", "P1D");
+  // Ends an hour before `timedEvent` to prove the ordering is correct.
+  let duringEvent = await addEvent("During Event", "P22H", "P23H");
+  // Starts at the same time as `timedEvent` ends to prove the ordering is correct.
+  let nextEvent = await addEvent("Next Event", "P1D", "P2D", true);
+
+  checkEvents(
+    { dateHeader: "Today", time: duringEvent.startDate, title: "During Event" },
+    {
+      // Should show "24:00" as the time and end today.
+      time: cal.dtz.formatter.formatTime(timedEvent.endDate, true),
+      title: "Timed Event",
+      overlap: "end",
+    },
+    { dateHeader: "Tomorrow", title: "Next Event" }
+  );
+
+  // Move the event fully into the displayed range.
+
+  let timedClone = timedEvent.clone();
+  timedClone.startDate.day += 2;
+  timedClone.endDate.day += 2;
+  await calendar.modifyItem(timedClone, timedEvent);
+
+  let duringClone = duringEvent.clone();
+  duringClone.startDate.day += 2;
+  duringClone.endDate.day += 2;
+  await calendar.modifyItem(duringClone, duringEvent);
+
+  let nextClone = nextEvent.clone();
+  nextClone.startDate.day += 2;
+  nextClone.endDate.day += 2;
+  await calendar.modifyItem(nextClone, nextEvent);
+
+  let realEndDate = today.clone();
+  realEndDate.day += 2;
+  checkEvents(
+    {
+      dateHeader: "Tomorrow",
+      time: timedClone.startDate,
+      title: "Timed Event",
+      overlap: "start",
+    },
+    { dateHeader: realEndDate, time: duringClone.startDate, title: "During Event" },
+    {
+      // Should show "24:00" as the time and end on the day after tomorrow.
+      time: cal.dtz.formatter.formatTime(timedClone.endDate, true),
+      title: "Timed Event",
+      overlap: "end",
+    },
+    { dateHeader: nextClone.startDate, title: "Next Event" }
+  );
+
+  await calendar.deleteItem(timedClone);
+  await calendar.deleteItem(duringClone);
+  await calendar.deleteItem(nextClone);
+});
+
+/**
+ * Check events that begin and/or end outside the date range. Events that have
+ * already started are listed as "Today", but still sorted by start time.
+ * All-day events are still sorted ahead of non-all-day events.
+ */
+add_task(async function testOverlapOutside() {
+  let before = await addEvent("Starts Before", "-P1D", "P1D", true);
+  checkEvents({ dateHeader: "Today", title: "Starts Before", overlap: "end" });
+
+  let after = await addEvent("Ends After", "P0D", "P9D", true);
+  checkEvents(
+    { dateHeader: "Today", title: "Starts Before", overlap: "end" },
+    { title: "Ends After", overlap: "start" }
+  );
+
+  let both = await addEvent("Beyond Start and End", "-P2D", "P9D", true);
+  checkEvents(
+    { dateHeader: "Today", title: "Beyond Start and End", overlap: "continue" },
+    { title: "Starts Before", overlap: "end" },
+    { title: "Ends After", overlap: "start" }
+  );
+
+  // Change `before` to begin earlier than `both`. They should swap places.
+
+  let startClone = before.clone();
+  startClone.startDate.day -= 2;
+  await calendar.modifyItem(startClone, before);
+  checkEvents(
+    { dateHeader: "Today", title: "Starts Before", overlap: "end" },
+    { title: "Beyond Start and End", overlap: "continue" },
+    { title: "Ends After", overlap: "start" }
+  );
+
+  let beforeWithTime = await addEvent("Starts Before with time", "-PT5H", "PT15H");
+  checkEvents(
+    { dateHeader: "Today", title: "Starts Before", overlap: "end" },
+    { title: "Beyond Start and End", overlap: "continue" },
+    { title: "Ends After", overlap: "start" },
+    // This is the end of the event so the end time is used.
+    { time: beforeWithTime.endDate, title: "Starts Before with time", overlap: "end" }
+  );
+
+  let afterWithTime = await addEvent("Ends After with time", "PT6H", "P8DT12H");
+  checkEvents(
+    { dateHeader: "Today", title: "Starts Before", overlap: "end" },
+    { title: "Beyond Start and End", overlap: "continue" },
+    { title: "Ends After", overlap: "start" },
+    { time: afterWithTime.startDate, title: "Ends After with time", overlap: "start" },
+    // This is the end of the event so the end time is used.
+    { time: beforeWithTime.endDate, title: "Starts Before with time", overlap: "end" }
+  );
+
+  let bothWithTime = await addEvent("Beyond Start and End with time", "-P2DT10H", "P9DT1H");
+  checkEvents(
+    { dateHeader: "Today", title: "Starts Before", overlap: "end" },
+    { title: "Beyond Start and End", overlap: "continue" },
+    { title: "Ends After", overlap: "start" },
+    { time: "", title: "Beyond Start and End with time", overlap: "continue" },
+    { time: afterWithTime.startDate, title: "Ends After with time", overlap: "start" },
+    // This is the end of the event so the end time is used.
+    { time: beforeWithTime.endDate, title: "Starts Before with time", overlap: "end" }
+  );
+
+  await calendar.deleteItem(before);
+  await calendar.deleteItem(after);
+  await calendar.deleteItem(both);
+  await calendar.deleteItem(beforeWithTime);
+  await calendar.deleteItem(afterWithTime);
+  await calendar.deleteItem(bothWithTime);
+});
+
+/**
+ * Checks that events that happened earlier today are marked as in the past,
+ * and events happening now are marked as such.
+ *
+ * This test may fail if run within a minute either side of midnight.
+ *
+ * It would be nice to test that as time passes events are changed
+ * appropriately, but that means waiting around for minutes and probably won't
+ * be very reliable, so we don't do that.
+ */
+add_task(async function testActive() {
+  let now = cal.dtz.now();
+
+  let pastEvent = await addEvent("Past Event", "PT0M", "PT1M");
+  let presentEvent = await addEvent("Present Event", `PT${now.hour}H`, `PT${now.hour + 1}H`);
+  let futureEvent = await addEvent("Future Event", "PT23H59M", "PT24H");
+  checkEvents(
+    { dateHeader: "Today", time: pastEvent.startDate, title: "Past Event" },
+    { time: presentEvent.startDate, title: "Present Event" },
+    { time: futureEvent.startDate, title: "Future Event" }
+  );
+
+  let [pastRow, presentRow, futureRow] = TodayPane.agenda.rows;
+  Assert.ok(pastRow.classList.contains("agenda-listitem-past"), "past event is marked past");
+  Assert.ok(!pastRow.classList.contains("agenda-listitem-now"), "past event is not marked now");
+  Assert.ok(
+    !presentRow.classList.contains("agenda-listitem-past"),
+    "present event is not marked past"
+  );
+  Assert.ok(presentRow.classList.contains("agenda-listitem-now"), "present event is marked now");
+  Assert.ok(
+    !futureRow.classList.contains("agenda-listitem-past"),
+    "future event is not marked past"
+  );
+  Assert.ok(!futureRow.classList.contains("agenda-listitem-now"), "future event is not marked now");
+
+  await calendar.deleteItem(pastEvent);
+  await calendar.deleteItem(presentEvent);
+  await calendar.deleteItem(futureEvent);
+});
+
+/**
+ * Checks events in different time zones are displayed correctly.
+ */
+add_task(async function testOtherTimeZones() {
+  // Johannesburg is UTC+2.
+  let johannesburg = cal.timezoneService.getTimezone("Africa/Johannesburg");
+  // Panama is UTC-5.
+  let panama = cal.timezoneService.getTimezone("America/Panama");
+
+  // All-day events are displayed on the day of the event, the time zone is ignored.
+
+  let allDayEvent = new CalEvent();
+  allDayEvent.id = cal.getUUID();
+  allDayEvent.title = "All-day event in Johannesburg";
+  allDayEvent.startDate = cal.createDateTime();
+  allDayEvent.startDate.resetTo(today.year, today.month, today.day + 1, 0, 0, 0, johannesburg);
+  allDayEvent.startDate.isDate = true;
+  allDayEvent.endDate = cal.createDateTime();
+  allDayEvent.endDate.resetTo(today.year, today.month, today.day + 2, 0, 0, 0, johannesburg);
+  allDayEvent.endDate.isDate = true;
+  allDayEvent = await calendar.addItem(allDayEvent);
+
+  checkEvents({
+    dateHeader: "Tomorrow",
+    title: "All-day event in Johannesburg",
+  });
+
+  await calendar.deleteItem(allDayEvent);
+
+  // The event time must be displayed in the local time zone, and the event must be sorted correctly.
+
+  let beforeEvent = await addEvent("Before", "P1DT5H", "P1DT6H");
+  let afterEvent = await addEvent("After", "P1DT7H", "P1DT8H");
+
+  let timedEvent = new CalEvent();
+  timedEvent.id = cal.getUUID();
+  timedEvent.title = "Morning in Johannesburg";
+  timedEvent.startDate = cal.createDateTime();
+  timedEvent.startDate.resetTo(today.year, today.month, today.day + 1, 8, 0, 0, johannesburg);
+  timedEvent.endDate = cal.createDateTime();
+  timedEvent.endDate.resetTo(today.year, today.month, today.day + 1, 12, 0, 0, johannesburg);
+  timedEvent = await calendar.addItem(timedEvent);
+
+  checkEvents(
+    {
+      dateHeader: "Tomorrow",
+      time: beforeEvent.startDate,
+      title: "Before",
+    },
+    {
+      time: cal.dtz.formatter.formatTime(cal.createDateTime("20000101T060000Z")), // The date used here is irrelevant.
+      title: "Morning in Johannesburg",
+    },
+    {
+      time: afterEvent.startDate,
+      title: "After",
+    }
+  );
+  Assert.stringContains(
+    TodayPane.agenda.rows[1].querySelector(".agenda-listitem-time").getAttribute("datetime"),
+    "T08:00:00+02:00"
+  );
+
+  await calendar.deleteItem(beforeEvent);
+  await calendar.deleteItem(afterEvent);
+  await calendar.deleteItem(timedEvent);
+
+  // Events that cross midnight in the local time zone (but not in the event time zone)
+  // must have a start row and an end row.
+
+  let overnightEvent = new CalEvent();
+  overnightEvent.id = cal.getUUID();
+  overnightEvent.title = "Evening in Panama";
+  overnightEvent.startDate = cal.createDateTime();
+  overnightEvent.startDate.resetTo(today.year, today.month, today.day, 17, 0, 0, panama);
+  overnightEvent.endDate = cal.createDateTime();
+  overnightEvent.endDate.resetTo(today.year, today.month, today.day, 23, 0, 0, panama);
+  overnightEvent = await calendar.addItem(overnightEvent);
+
+  checkEvents(
+    {
+      dateHeader: "Today",
+      time: cal.dtz.formatter.formatTime(cal.createDateTime("20000101T220000Z")), // The date used here is irrelevant.
+      title: "Evening in Panama",
+      overlap: "start",
+    },
+    {
+      dateHeader: "Tomorrow",
+      time: cal.dtz.formatter.formatTime(cal.createDateTime("20000101T040000Z")), // The date used here is irrelevant.
+      title: "Evening in Panama",
+      overlap: "end",
+    }
+  );
+  Assert.stringContains(
+    TodayPane.agenda.rows[0].querySelector(".agenda-listitem-time").getAttribute("datetime"),
+    "T17:00:00-05:00"
+  );
+  Assert.stringContains(
+    TodayPane.agenda.rows[1].querySelector(".agenda-listitem-time").getAttribute("datetime"),
+    "T23:00:00-05:00"
+  );
+
+  await calendar.deleteItem(overnightEvent);
+});
+
+/**
+ * Checks events in different time zones are displayed correctly.
+ */
+add_task(async function testRelativeTime() {
+  let formatter = new Intl.RelativeTimeFormat(undefined, { style: "short" });
+  let now = cal.dtz.now();
+  now.second = 0;
+  info(`The time is now ${now}`);
+
+  let testData = [
+    {
+      name: "two hours ago",
+      start: "-PT1H55M",
+      expected: {
+        classes: ["agenda-listitem-past"],
+      },
+      minHour: 2,
+    },
+    {
+      name: "one hour ago",
+      start: "-PT1H5M",
+      expected: {
+        classes: ["agenda-listitem-past"],
+      },
+      minHour: 2,
+    },
+    {
+      name: "23 minutes ago",
+      start: "-PT23M",
+      expected: {
+        classes: ["agenda-listitem-past"],
+      },
+      minHour: 1,
+    },
+    {
+      name: "now",
+      start: "-PT5M",
+      expected: {
+        relative: ["now"],
+        classes: ["agenda-listitem-now"],
+      },
+      minHour: 1,
+      maxHour: 22,
+    },
+    {
+      name: "19 minutes ahead",
+      start: "PT19M",
+      expected: {
+        relative: [formatter.format(19, "minute"), formatter.format(18, "minute")],
+      },
+      maxHour: 22,
+    },
+    {
+      name: "one hour ahead",
+      start: "PT1H25M",
+      expected: {
+        relative: [formatter.format(85, "minute"), formatter.format(84, "minute")],
+      },
+      maxHour: 21,
+    },
+    {
+      name: "one and half hours ahead",
+      start: "PT1H35M",
+      expected: {
+        relative: [formatter.format(2, "hour")],
+      },
+      maxHour: 21,
+    },
+    {
+      name: "two hours ahead",
+      start: "PT1H49M",
+      expected: {
+        relative: [formatter.format(2, "hour")],
+      },
+      maxHour: 21,
+    },
+  ];
+
+  let events = [];
+  let expectedEvents = [];
+  for (let { name, start, expected, minHour, maxHour } of testData) {
+    if (minHour && now.hour < minHour) {
+      info(`Skipping ${name} because it's too early.`);
+      continue;
+    }
+    if (maxHour && now.hour > maxHour) {
+      info(`Skipping ${name} because it's too late.`);
+      continue;
+    }
+
+    let event = new CalEvent();
+    event.id = cal.getUUID();
+    event.title = name;
+    event.startDate = now.clone();
+    event.startDate.addDuration(cal.createDuration(start));
+    event.endDate = event.startDate.clone();
+    event.endDate.addDuration(cal.createDuration("PT10M"));
+    events.push(await calendar.addItem(event));
+
+    expectedEvents.push({ ...expected, title: name, time: event.startDate });
+  }
+
+  expectedEvents[0].dateHeader = "Today";
+  checkEvents(...expectedEvents);
+
+  for (let event of events) {
+    await calendar.deleteItem(event);
+  }
+});
+
+/**
+ * Tests the today pane opens events in the summary dialog for both
+ * non-recurring and recurring events.
+ */
+add_task(async function testOpenEvent() {
+  let noRepeatEvent = new CalEvent();
+  noRepeatEvent.id = "no repeat event";
+  noRepeatEvent.title = "No Repeat Event";
+  noRepeatEvent.startDate = today.clone();
+  noRepeatEvent.startDate.hour = startHour;
+  noRepeatEvent.endDate = noRepeatEvent.startDate.clone();
+  noRepeatEvent.endDate.hour++;
+
+  let repeatEvent = new CalEvent();
+  repeatEvent.id = "repeated event";
+  repeatEvent.title = "Repeated Event";
+  repeatEvent.startDate = today.clone();
+  repeatEvent.startDate.hour = startHour;
+  repeatEvent.endDate = noRepeatEvent.startDate.clone();
+  repeatEvent.endDate.hour++;
+  repeatEvent.recurrenceInfo = new CalRecurrenceInfo(repeatEvent);
+  repeatEvent.recurrenceInfo.appendRecurrenceItem(
+    cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=5")
+  );
+
+  for (let event of [noRepeatEvent, repeatEvent]) {
+    let addedEvent = await calendar.addItem(event);
+
+    if (event == noRepeatEvent) {
+      Assert.equal(TodayPane.agenda.rowCount, 1);
+    } else {
+      Assert.equal(TodayPane.agenda.rowCount, 5);
+    }
+    Assert.equal(
+      TodayPane.agenda.rows[0].querySelector(".agenda-listitem-title").textContent,
+      event.title,
+      "event title is correct"
+    );
+
+    let dialogWindowPromise = CalendarTestUtils.waitForEventDialog();
+    EventUtils.synthesizeMouseAtCenter(TodayPane.agenda.rows[0], { clickCount: 2 });
+
+    let dialogWindow = await dialogWindowPromise;
+    let docUri = dialogWindow.document.documentURI;
+    Assert.ok(
+      docUri === "chrome://calendar/content/calendar-summary-dialog.xhtml",
+      "event summary dialog shown"
+    );
+
+    await BrowserTestUtils.closeWindow(dialogWindow);
+    await calendar.deleteItem(addedEvent);
+  }
+});
+
+/**
+ * Tests that the "New Event" button begins creating an event on the date
+ * selected in the Today Pane.
+ */
+add_task(async function testNewEvent() {
+  async function checkEventDialogDate() {
+    let dialogWindowPromise = CalendarTestUtils.waitForEventDialog("edit");
+    EventUtils.synthesizeMouseAtCenter(newEventButton, {}, window);
+    await dialogWindowPromise.then(async function (dialogWindow) {
+      let iframe = dialogWindow.document.querySelector("#calendar-item-panel-iframe");
+      let iframeDocument = iframe.contentDocument;
+
+      let startDate = iframeDocument.getElementById("event-starttime");
+      Assert.equal(
+        startDate._datepicker._inputField.value,
+        formatDate(expectedDate),
+        "date should match the expected date"
+      );
+      Assert.equal(
+        startDate._timepicker._inputField.value,
+        formatTime(expectedDate),
+        "time should be the next hour after now"
+      );
+
+      await BrowserTestUtils.closeWindow(dialogWindow);
+    });
+  }
+
+  let newEventButton = document.getElementById("todaypane-new-event-button");
+
+  // Check today with the "day" view.
+
+  TodayPane.displayMiniSection("miniday");
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("today-button"), {}, window);
+
+  let expectedDate = cal.dtz.now();
+  expectedDate.hour++;
+  expectedDate.minute = 0;
+
+  await checkEventDialogDate();
+
+  // Check tomorrow with the "day" view.
+
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("next-day-button"), {}, window);
+  expectedDate.day++;
+
+  await checkEventDialogDate();
+
+  // Check today with the "month" view;
+
+  TodayPane.displayMiniSection("minimonth");
+  let minimonth = document.getElementById("today-minimonth");
+  minimonth.value = new Date();
+  expectedDate.day--;
+
+  await checkEventDialogDate();
+
+  // Check a date in the past with the "month" view;
+
+  minimonth.value = new Date(Date.UTC(2018, 8, 1));
+  expectedDate.resetTo(2018, 8, 1, expectedDate.hour, 0, 0, cal.dtz.UTC);
+
+  await checkEventDialogDate();
+}).__skipMe = new Date().getUTCHours() == 23;
diff --git a/comm/calendar/test/browser/browser_todayPane_dragAndDrop.js b/comm/calendar/test/browser/browser_todayPane_dragAndDrop.js
new file mode 100644
index 0000000000..bac91ed60d
--- /dev/null
+++ b/comm/calendar/test/browser/browser_todayPane_dragAndDrop.js
@@ -0,0 +1,262 @@
+/* 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/. */
+
+/**
+ * Tests for drag and drop on the today pane.
+ */
+const { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+const { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+const {
+  add_message_to_folder,
+  be_in_folder,
+  create_folder,
+  create_message,
+  inboxFolder,
+  select_click_row,
+} = ChromeUtils.import("resource://testing-common/mozmill/FolderDisplayHelpers.jsm");
+const { SyntheticPartLeaf } = ChromeUtils.import(
+  "resource://testing-common/mailnews/MessageGenerator.jsm"
+);
+
+const calendar = CalendarTestUtils.createCalendar("Mochitest", "memory");
+registerCleanupFunction(() => CalendarTestUtils.removeCalendar(calendar));
+
+/**
+ * Ensures the today pane is visible for each test.
+ */
+async function ensureTodayPane() {
+  let todayPane = document.querySelector("#today-pane-panel");
+  if (!todayPane.isVisible()) {
+    todayPane.setVisible(true, true, true);
+  }
+
+  await TestUtils.waitForCondition(() => todayPane.isVisible(), "today pane not visible in time");
+}
+
+/**
+ * Tests dropping a message from the message pane on to the today pane brings
+ * up the new event dialog.
+ */
+add_task(async function testDropMozMessage() {
+  let folder = await create_folder("Mochitest");
+  let subject = "The Grand Event";
+  let body = "Parking is available.";
+  await be_in_folder(folder);
+  await add_message_to_folder([folder], create_message({ subject, body: { body } }));
+  select_click_row(0);
+
+  let about3PaneTab = document.getElementById("tabmail").currentTabInfo;
+  let msg = about3PaneTab.message;
+  let msgStr = about3PaneTab.folder.getUriForMsg(msg);
+  let msgUrl = MailServices.messageServiceFromURI(msgStr).getUrlForUri(msgStr);
+
+  // Setup a DataTransfer to mimic what ThreadPaneOnDragStart sends.
+  let dataTransfer = new DataTransfer();
+  dataTransfer.mozSetDataAt("text/x-moz-message", msgStr, 0);
+  dataTransfer.mozSetDataAt("text/x-moz-url", msgUrl.spec, 0);
+  dataTransfer.mozSetDataAt(
+    "application/x-moz-file-promise-url",
+    msgUrl.spec + "?fileName=" + encodeURIComponent("message.eml"),
+    0
+  );
+  dataTransfer.mozSetDataAt(
+    "application/x-moz-file-promise",
+    new window.messageFlavorDataProvider(),
+    0
+  );
+
+  let promise = CalendarTestUtils.waitForEventDialog("edit");
+  await ensureTodayPane();
+  document.querySelector("#agenda").dispatchEvent(new DragEvent("drop", { dataTransfer }));
+
+  let eventWindow = await promise;
+  let iframe = eventWindow.document.querySelector("#calendar-item-panel-iframe");
+  let iframeDoc = iframe.contentDocument;
+
+  Assert.equal(
+    iframeDoc.querySelector("#item-title").value,
+    subject,
+    "the message subject was used as the event title"
+  );
+  Assert.equal(
+    iframeDoc.querySelector("#item-description").contentDocument.body.innerText,
+    body,
+    "the message body was used as the event description"
+  );
+
+  await BrowserTestUtils.closeWindow(eventWindow);
+  await be_in_folder(inboxFolder);
+  folder.deleteSelf(null);
+});
+
+/**
+ * Tests dropping an entry from the address book adds the address as an attendee
+ * to a new event when dropped on the today pane.
+ */
+add_task(async function testMozAddressDrop() {
+  let vcard = CalendarTestUtils.dedent`
+  BEGIN:VCARD
+  VERSION:4.0
+  EMAIL;PREF=1:person@example.com
+  FN:Some Person
+  N:Some;Person;;;
+  UID:d5f9113d-5ede-4a5c-ba8e-0f2345369993
+  END:VCARD
+  `;
+
+  let address = "Some Person <person@example.com>";
+
+  // Setup a DataTransfer to mimic what the address book sends.
+  let dataTransfer = new DataTransfer();
+  dataTransfer.setData("moz/abcard", "0");
+  dataTransfer.setData("text/x-moz-address", address);
+  dataTransfer.setData("text/plain", address);
+  dataTransfer.setData("text/vcard", decodeURIComponent(vcard));
+  dataTransfer.setData("application/x-moz-file-promise-dest-filename", "person.vcf");
+  dataTransfer.setData("application/x-moz-file-promise-url", "data:text/vcard," + vcard);
+  dataTransfer.setData("application/x-moz-file-promise", window.abFlavorDataProvider);
+
+  let promise = CalendarTestUtils.waitForEventDialog("edit");
+  await ensureTodayPane();
+  document.querySelector("#agenda").dispatchEvent(new DragEvent("drop", { dataTransfer }));
+
+  let eventWindow = await promise;
+  let iframe = eventWindow.document.querySelector("#calendar-item-panel-iframe");
+  let iframeWin = iframe.cotnentWindow;
+  let iframeDoc = iframe.contentDocument;
+
+  // Verify the address was added as an attendee.
+  EventUtils.synthesizeMouseAtCenter(
+    iframeDoc.querySelector("#event-grid-tab-attendees"),
+    {},
+    iframeWin
+  );
+
+  let box = iframeDoc.querySelector('[attendeeid="mailto:person@example.com"]');
+  Assert.ok(box, "address included as an attendee to the new event");
+  await BrowserTestUtils.closeWindow(eventWindow);
+});
+
+/**
+ * Tests dropping plain text that is actually ics data format is picked up by
+ * the today pane.
+ */
+add_task(async function testPlainTextICSDrop() {
+  let event = CalendarTestUtils.dedent`
+  BEGIN:VCALENDAR
+  BEGIN:VEVENT
+  SUMMARY:An Event
+  DESCRIPTION:Parking is not available.
+  DTSTART:20210325T110000Z
+  DTEND:20210325T120000Z
+  UID:916bd967-35ac-40f6-8cd5-487739c9d245
+  END:VEVENT
+  END:VCALENDAR
+  `;
+
+  // Setup a DataTransfer to mimic what the address book sends.
+  let dataTransfer = new DataTransfer();
+  dataTransfer.setData("text/plain", event);
+
+  let promise = CalendarTestUtils.waitForEventDialog("edit");
+  await ensureTodayPane();
+  document.querySelector("#agenda").dispatchEvent(new DragEvent("drop", { dataTransfer }));
+
+  let eventWindow = await promise;
+  let iframe = eventWindow.document.querySelector("#calendar-item-panel-iframe");
+  let iframeDoc = iframe.contentDocument;
+  Assert.equal(iframeDoc.querySelector("#item-title").value, "An Event");
+
+  let startTime = iframeDoc.querySelector("#event-starttime");
+  Assert.equal(
+    startTime._datepicker._inputBoxValue,
+    cal.dtz.formatter.formatDateShort(cal.createDateTime("20210325T110000Z"))
+  );
+
+  let endTime = iframeDoc.querySelector("#event-endtime");
+  Assert.equal(
+    endTime._datepicker._inputBoxValue,
+    cal.dtz.formatter.formatDateShort(cal.createDateTime("20210325T120000Z"))
+  );
+
+  Assert.equal(
+    iframeDoc.querySelector("#item-description").contentDocument.body.innerText,
+    "Parking is not available."
+  );
+  await BrowserTestUtils.closeWindow(eventWindow);
+});
+
+/**
+ * Tests dropping a file with an ics extension on the today pane is parsed as an
+ * ics file.
+ */
+add_task(async function testICSFileDrop() {
+  let file = await File.createFromFileName(getTestFilePath("data/event.ics"));
+  let dataTransfer = new DataTransfer();
+  dataTransfer.items.add(file);
+
+  let promise = CalendarTestUtils.waitForEventDialog("edit");
+  await ensureTodayPane();
+
+  // For some reason, dataTransfer.items.add() results in a mozItemCount of 2
+  // instead of one. Call onExternalDrop directly to get around that.
+  window.calendarCalendarButtonDNDObserver.onExternalDrop(dataTransfer);
+
+  let eventWindow = await promise;
+  let iframe = eventWindow.document.querySelector("#calendar-item-panel-iframe");
+  let iframeDoc = iframe.contentDocument;
+
+  Assert.equal(iframeDoc.querySelector("#item-title").value, "An Event");
+
+  let startTime = iframeDoc.querySelector("#event-starttime");
+  Assert.equal(
+    startTime._datepicker._inputBoxValue,
+    cal.dtz.formatter.formatDateShort(cal.createDateTime("20210325T110000Z"))
+  );
+
+  let endTime = iframeDoc.querySelector("#event-endtime");
+  Assert.equal(
+    endTime._datepicker._inputBoxValue,
+    cal.dtz.formatter.formatDateShort(cal.createDateTime("20210325T120000Z"))
+  );
+
+  Assert.equal(
+    iframeDoc.querySelector("#item-description").contentDocument.body.innerText,
+    "Parking is not available."
+  );
+  await BrowserTestUtils.closeWindow(eventWindow);
+});
+
+/**
+ * Tests dropping any other file on the today pane ends up as an attachment
+ * to a new event.
+ */
+add_task(async function testOtherFileDrop() {
+  let file = await File.createFromNsIFile(
+    new FileUtils.File(getTestFilePath("data/attachment.png"))
+  );
+  let dataTransfer = new DataTransfer();
+  dataTransfer.setData("image/png", file);
+  dataTransfer.items.add(file);
+
+  let promise = CalendarTestUtils.waitForEventDialog("edit");
+  await ensureTodayPane();
+  document.querySelector("#agenda").dispatchEvent(new DragEvent("drop", { dataTransfer }));
+
+  let eventWindow = await promise;
+  let iframe = eventWindow.document.querySelector("#calendar-item-panel-iframe");
+  let iframeWin = iframe.contentWindow;
+  let iframeDoc = iframe.contentDocument;
+
+  EventUtils.synthesizeMouseAtCenter(
+    iframeDoc.querySelector("#event-grid-tab-attachments"),
+    {},
+    iframeWin
+  );
+
+  let listBox = iframeDoc.querySelector("#attachment-link");
+  let listItem = listBox.itemChildren[0];
+  Assert.equal(listItem.querySelector("label").value, "attachment.png");
+  await BrowserTestUtils.closeWindow(eventWindow);
+});
diff --git a/comm/calendar/test/browser/browser_todayPane_visibility.js b/comm/calendar/test/browser/browser_todayPane_visibility.js
new file mode 100644
index 0000000000..d2176218ed
--- /dev/null
+++ b/comm/calendar/test/browser/browser_todayPane_visibility.js
@@ -0,0 +1,167 @@
+/* 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/. */
+
+/* globals openAddonsTab, openChatTab, openNewCalendarEventTab,
+ * openNewCalendarTaskTab, openPreferencesTab, openTasksTab,
+ * selectCalendarEventTab, selectCalendarTaskTab, selectFolderTab,
+ * toAddressBook */
+
+// Test that today pane is visible/collapsed correctly for various tab types.
+// In all cases today pane should not be visible in preferences or addons tab.
+// Also test that the today pane button is visible/hidden for various tab types.
+add_task(async () => {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  const todayPane = document.getElementById("today-pane-panel");
+  const todayPaneButton = document.getElementById("calendar-status-todaypane-button");
+
+  let eventTabPanelId, taskTabPanelId;
+
+  async function clickTodayPaneButton() {
+    // The today pane button will be hidden for certain tabs (e.g. preferences), and then
+    // the user won't be able to click it, so we shouldn't be able to here either.
+    if (BrowserTestUtils.is_visible(todayPaneButton)) {
+      EventUtils.synthesizeMouseAtCenter(todayPaneButton, { clickCount: 1 });
+    }
+    await new Promise(resolve => setTimeout(resolve));
+  }
+
+  /**
+   * Tests whether the today pane is only open in certain tabs.
+   *
+   * @param {string[]} tabsWhereVisible - Array of tab mode names for tabs where
+   *                                      the today pane should be visible.
+   */
+  async function checkTodayPaneVisibility(tabsWhereVisible) {
+    function check(tabModeName) {
+      let shouldBeVisible = tabsWhereVisible.includes(tabModeName);
+      is(
+        BrowserTestUtils.is_visible(todayPane),
+        shouldBeVisible,
+        `today pane is ${shouldBeVisible ? "visible" : "collapsed"} in ${tabModeName} tab`
+      );
+    }
+
+    await selectFolderTab();
+    check("folder");
+    await CalendarTestUtils.openCalendarTab(window);
+    check("calendar");
+    await openTasksTab();
+    check("tasks");
+    await openChatTab();
+    check("chat");
+    await selectCalendarEventTab(eventTabPanelId);
+    check("calendarEvent");
+    await selectCalendarTaskTab(taskTabPanelId);
+    check("calendarTask");
+    await toAddressBook();
+    check("addressBookTab");
+    await openPreferencesTab();
+    check("preferencesTab");
+    await openAddonsTab();
+    check("contentTab");
+  }
+
+  // Show today pane in folder (mail) tab, but not in other tabs.
+  await selectFolderTab();
+  if (!BrowserTestUtils.is_visible(todayPane)) {
+    await clickTodayPaneButton();
+  }
+  await CalendarTestUtils.openCalendarTab(window);
+  if (BrowserTestUtils.is_visible(todayPane)) {
+    await clickTodayPaneButton();
+  }
+  await openTasksTab();
+  if (BrowserTestUtils.is_visible(todayPane)) {
+    await clickTodayPaneButton();
+  }
+  await openChatTab();
+  if (BrowserTestUtils.is_visible(todayPane)) {
+    await clickTodayPaneButton();
+  }
+  eventTabPanelId = await openNewCalendarEventTab();
+  if (BrowserTestUtils.is_visible(todayPane)) {
+    await clickTodayPaneButton();
+  }
+  taskTabPanelId = await openNewCalendarTaskTab();
+  if (BrowserTestUtils.is_visible(todayPane)) {
+    await clickTodayPaneButton();
+  }
+
+  await checkTodayPaneVisibility(["folder"]);
+
+  // Show today pane in calendar tab, but not in other tabs.
+  // Hide it in folder tab.
+  await selectFolderTab();
+  await clickTodayPaneButton();
+  // Show it in calendar tab.
+  await CalendarTestUtils.openCalendarTab(window);
+  await clickTodayPaneButton();
+
+  await checkTodayPaneVisibility(["calendar"]);
+
+  // Show today pane in tasks tab, but not in other tabs.
+  // Hide it in calendar tab.
+  await CalendarTestUtils.openCalendarTab(window);
+  await clickTodayPaneButton();
+  // Show it in tasks tab.
+  await openTasksTab();
+  await clickTodayPaneButton();
+
+  await checkTodayPaneVisibility(["tasks"]);
+
+  // Show today pane in chat tab, but not in other tabs.
+  // Hide it in tasks tab.
+  await openTasksTab();
+  await clickTodayPaneButton();
+  // Show it in chat tab.
+  await openChatTab();
+  await clickTodayPaneButton();
+
+  await checkTodayPaneVisibility(["chat"]);
+
+  // Show today pane in calendar event tab, but not in other tabs.
+  // Hide it in chat tab.
+  await openChatTab();
+  await clickTodayPaneButton();
+  // Show it in calendar event tab.
+  await selectCalendarEventTab(eventTabPanelId);
+  await clickTodayPaneButton();
+
+  await checkTodayPaneVisibility(["calendarEvent"]);
+
+  // Show today pane in calendar task tab, but not in other tabs.
+  // Hide it in calendar event tab.
+  await selectCalendarEventTab(eventTabPanelId);
+  await clickTodayPaneButton();
+  // Show it in calendar task tab.
+  await selectCalendarTaskTab(taskTabPanelId);
+  await clickTodayPaneButton();
+
+  await checkTodayPaneVisibility(["calendarTask"]);
+
+  // Check the visibility of the today pane button.
+  const button = document.getElementById("calendar-status-todaypane-button");
+  await selectFolderTab();
+  ok(BrowserTestUtils.is_visible(button), "today pane button is visible in folder tab");
+  await CalendarTestUtils.openCalendarTab(window);
+  ok(BrowserTestUtils.is_visible(button), "today pane button is visible in calendar tab");
+  await openTasksTab();
+  ok(BrowserTestUtils.is_visible(button), "today pane button is visible in tasks tab");
+  await openChatTab();
+  ok(BrowserTestUtils.is_visible(button), "today pane button is visible in chat tab");
+  await selectCalendarEventTab(eventTabPanelId);
+  ok(BrowserTestUtils.is_visible(button), "today pane button is visible in event tab");
+  await selectCalendarTaskTab(taskTabPanelId);
+  ok(BrowserTestUtils.is_visible(button), "today pane button is visible in task tab");
+  await toAddressBook();
+  is(BrowserTestUtils.is_visible(button), false, "today pane button is hidden in address book tab");
+  await openPreferencesTab();
+  is(BrowserTestUtils.is_visible(button), false, "today pane button is hidden in preferences tab");
+  await openAddonsTab();
+  is(BrowserTestUtils.is_visible(button), false, "today pane button is hidden in addons tab");
+});
diff --git a/comm/calendar/test/browser/contextMenu/browser.ini b/comm/calendar/test/browser/contextMenu/browser.ini
new file mode 100644
index 0000000000..b6590e849c
--- /dev/null
+++ b/comm/calendar/test/browser/contextMenu/browser.ini
@@ -0,0 +1,14 @@
+[default]
+prefs =
+  calendar.item.promptDelete=false
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+  calendar.week.start=0
+  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_edit.js]
diff --git a/comm/calendar/test/browser/contextMenu/browser_edit.js b/comm/calendar/test/browser/contextMenu/browser_edit.js
new file mode 100644
index 0000000000..672055709f
--- /dev/null
+++ b/comm/calendar/test/browser/contextMenu/browser_edit.js
@@ -0,0 +1,187 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+const { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+/**
+ * Grabs a calendar-month-day-box-item from the view using an attribute CSS
+ * selector. Only works when the calendar is in month view.
+ */
+async function getDayBoxItem(attrSelector) {
+  let itemBox;
+  await TestUtils.waitForCondition(() => {
+    itemBox = document.querySelector(
+      `calendar-month-day-box[${attrSelector}] calendar-month-day-box-item`
+    );
+    return itemBox != null;
+  }, "calendar item did not appear in time");
+  return itemBox;
+}
+
+/**
+ * Switches to the view to the calendar.
+ */
+add_setup(function () {
+  return CalendarTestUtils.setCalendarView(window, "month");
+});
+
+/**
+ * Tests the "Edit" menu item is available and opens up the event dialog.
+ */
+add_task(async function testEditEditableItem() {
+  let calendar = CalendarTestUtils.createCalendar("Editable", "memory");
+  registerCleanupFunction(() => CalendarTestUtils.removeCalendar(calendar));
+
+  let title = "Editable Event";
+  let event = new CalEvent();
+  event.title = title;
+  event.startDate = cal.createDateTime("20200101T000001Z");
+
+  await calendar.addItem(event);
+  window.goToDate(event.startDate);
+
+  let menu = document.querySelector("#calendar-item-context-menu");
+  let editMenu = document.querySelector("#calendar-item-context-menu-modify-menuitem");
+  let popupPromise = BrowserTestUtils.waitForEvent(menu, "popupshown");
+
+  EventUtils.synthesizeMouseAtCenter(await getDayBoxItem('day="1"'), { type: "contextmenu" });
+  await popupPromise;
+  Assert.ok(!editMenu.disabled, 'context menu "Edit" item is not disabled for editable event');
+
+  let editDialogPromise = BrowserTestUtils.domWindowOpened(null, async win => {
+    await BrowserTestUtils.waitForEvent(win, "load");
+
+    let doc = win.document;
+    Assert.ok(
+      doc.documentURI == "chrome://calendar/content/calendar-event-dialog.xhtml",
+      "editing event dialog opened"
+    );
+
+    let iframe = doc.querySelector("#calendar-item-panel-iframe");
+    await BrowserTestUtils.waitForEvent(iframe.contentWindow, "load");
+
+    let iframeDoc = iframe.contentDocument;
+    Assert.ok(
+      (iframeDoc.querySelector("#item-title").value = title),
+      'context menu "Edit" item opens the editing dialog'
+    );
+    doc.querySelector("dialog").acceptDialog();
+    return true;
+  });
+
+  menu.activateItem(editMenu);
+  await editDialogPromise;
+});
+
+/**
+ * Tests that the "Edit" menu item is disabled for events we are not allowed to
+ * modify.
+ */
+add_task(async function testEditNonEditableItem() {
+  let calendar = CalendarTestUtils.createCalendar("Non-Editable", "memory");
+  registerCleanupFunction(() => CalendarTestUtils.removeCalendar(calendar));
+
+  let event = new CalEvent();
+  let acl = {
+    QueryInterface: ChromeUtils.generateQI(["calIItemACLEntry"]),
+    userCanModify: false,
+    userCanRespond: true,
+    userCanViewAll: true,
+    userCanViewDateAndTime: true,
+    calendarEntry: {
+      hasAccessControl: true,
+      userIsOwner: false,
+    },
+  };
+  event.title = "Read Only Event";
+  event.startDate = cal.createDateTime("20200102T000001Z");
+  event.mACLEntry = acl;
+
+  await calendar.addItem(event);
+  window.goToDate(event.startDate);
+
+  let menu = document.querySelector("#calendar-item-context-menu");
+  let editMenu = document.querySelector("#calendar-item-context-menu-modify-menuitem");
+  let popupPromise = BrowserTestUtils.waitForEvent(menu, "popupshowing");
+
+  EventUtils.synthesizeMouseAtCenter(await getDayBoxItem('day="2"'), { type: "contextmenu" });
+  await popupPromise;
+  Assert.ok(editMenu.disabled, 'context menu "Edit" item is disabled for non-editable event');
+  menu.hidePopup();
+});
+
+/**
+ * Tests that the "Edit" menu item is disabled when the event is an invitation.
+ */
+add_task(async function testInvitation() {
+  let calendar = CalendarTestUtils.createCalendar("Invitation", "memory");
+  calendar.setProperty("organizerId", "mailto:attendee@example.com");
+  registerCleanupFunction(() => CalendarTestUtils.removeCalendar(calendar));
+
+  let icalString = CalendarTestUtils.dedent`
+    BEGIN:VEVENT
+    CREATED:20200103T152601Z
+    DTSTAMP:20200103T192729Z
+    UID:x131e
+    SUMMARY:Invitation
+    ORGANIZER;CN=Org:mailto:organizer@example.com
+    ATTENDEE;RSVP=TRUE;CN=attendee@example.com;PARTSTAT=NEEDS-ACTION;CUTY
+     PE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;X-NUM-GUESTS=0:mailto:attendee@example.com
+    DTSTART:20200103T153000Z
+    DTEND:20200103T163000Z
+    DESCRIPTION:Just a Test
+    SEQUENCE:0
+    TRANSP:OPAQUE
+    END:VEVENT
+  `;
+
+  let invitation = new CalEvent(icalString);
+  await calendar.addItem(invitation);
+  window.goToDate(invitation.startDate);
+
+  let menu = document.querySelector("#calendar-item-context-menu");
+  let editMenu = document.querySelector("#calendar-item-context-menu-modify-menuitem");
+  let popupPromise = BrowserTestUtils.waitForEvent(menu, "popupshowing");
+
+  EventUtils.synthesizeMouseAtCenter(await getDayBoxItem('day="3"'), { type: "contextmenu" });
+  await popupPromise;
+  Assert.ok(editMenu.disabled, 'context menu "Edit" item is disabled for invitations');
+  menu.hidePopup();
+});
+
+/**
+ * Tests that the "Edit" menu item is disabled when the calendar is read-only.
+ */
+add_task(async function testCalendarReadOnly() {
+  let calendar = CalendarTestUtils.createCalendar("ReadOnly", "memory");
+  registerCleanupFunction(() => CalendarTestUtils.removeCalendar(calendar));
+
+  let event = new CalEvent();
+  event.title = "ReadOnly Event";
+  event.startDate = cal.createDateTime("20200104T000001Z");
+
+  await calendar.addItem(event);
+  calendar.setProperty("readOnly", true);
+  window.goToDate(event.startDate);
+
+  let menu = document.querySelector("#calendar-item-context-menu");
+  let editMenu = document.querySelector("#calendar-item-context-menu-modify-menuitem");
+  let popupPromise = BrowserTestUtils.waitForEvent(menu, "popupshowing");
+
+  EventUtils.synthesizeMouseAtCenter(await getDayBoxItem('day="4"'), { type: "contextmenu" });
+  await popupPromise;
+  Assert.ok(editMenu.disabled, 'context menu "Edit" item is disabled when calendar is read-only');
+  menu.hidePopup();
+});
+
+registerCleanupFunction(() => {
+  return CalendarTestUtils.closeCalendarTab(window);
+});
diff --git a/comm/calendar/test/browser/data/attachment.png b/comm/calendar/test/browser/data/attachment.png
new file mode 100644
index 0000000000..30caecab7b
--- /dev/null
+++ b/comm/calendar/test/browser/data/attachment.png
diff --git a/comm/calendar/test/browser/data/calendars.sjs b/comm/calendar/test/browser/data/calendars.sjs
new file mode 100644
index 0000000000..f1175f1903
--- /dev/null
+++ b/comm/calendar/test/browser/data/calendars.sjs
@@ -0,0 +1,126 @@
+/* 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/. */
+
+Cu.importGlobalProperties(["TextEncoder"]);
+
+function handleRequest(request, response) {
+  if (!request.hasHeader("Authorization")) {
+    response.setStatusLine("1.1", 401, "Unauthorized");
+    response.setHeader("WWW-Authenticate", `Basic realm="test"`);
+    return;
+  }
+
+  response.setStatusLine("1.1", 207, "Multi-Status");
+  response.setHeader("Content-Type", "text/xml; charset=utf-8", false);
+
+  // Request:
+  // <propfind>
+  //   <prop>
+  //     <resourcetype/>
+  //     <displayname/>
+  //     <current-user-privilege-set/>
+  //     <calendar-color/>
+  //   </prop>
+  // </propfind>
+
+  let res = `<multistatus xmlns="DAV:"
+                               xmlns:A="http://apple.com/ns/ical/"
+                               xmlns:C="urn:ietf:params:xml:ns:caldav"
+                               xmlns:CS="http://calendarserver.org/ns/">
+    <response>
+      <href>/browser/comm/calendar/test/browser/data/calendars.sjs</href>
+      <propstat>
+        <prop>
+          <resourcetype>
+            <collection/>
+          </resourcetype>
+          <displayname>Things found by DNS</displayname>
+        </prop>
+        <status>HTTP/1.1 200 OK</status>
+      </propstat>
+      <propstat>
+        <prop>
+          <current-user-privilege-set/>
+          <A:calendar-color/>
+        </prop>
+        <status>HTTP/1.1 404 Not Found</status>
+      </propstat>
+    </response>
+    <response>
+      <href>/browser/comm/calendar/test/browser/data/calendar.sjs</href>
+      <propstat>
+        <prop>
+          <resourcetype>
+            <collection/>
+            <C:calendar/>
+            <CS:shared/>
+          </resourcetype>
+          <displayname>You found me!</displayname>
+          <A:calendar-color>#008000</A:calendar-color>
+        </prop>
+        <status>HTTP/1.1 200 OK</status>
+      </propstat>
+      <propstat>
+        <prop>
+          <current-user-privilege-set/>
+        </prop>
+        <status>HTTP/1.1 404 Not Found</status>
+      </propstat>
+    </response>
+    <response>
+      <href>/browser/comm/calendar/test/browser/data/calendar2.sjs</href>
+      <propstat>
+        <prop>
+          <resourcetype>
+            <collection/>
+            <C:calendar/>
+            <CS:shared/>
+          </resourcetype>
+          <displayname>Röda dagar</displayname>
+          <A:calendar-color>#ff0000</A:calendar-color>
+          <current-user-privilege-set>
+           <privilege>
+            <read/>
+           </privilege>
+           <privilege>
+            <C:read-free-busy/>
+           </privilege>
+           <privilege>
+            <read-current-user-privilege-set/>
+           </privilege>
+           <privilege>
+            <write/>
+           </privilege>
+           <privilege>
+            <write-content/>
+           </privilege>
+           <privilege>
+            <write-properties/>
+           </privilege>
+           <privilege>
+            <bind/>
+           </privilege>
+           <privilege>
+            <unbind/>
+           </privilege>
+          </current-user-privilege-set>
+        </prop>
+        <status>HTTP/1.1 200 OK</status>
+      </propstat>
+      <propstat>
+        <prop>
+          <current-user-privilege-set/>
+        </prop>
+        <status>HTTP/1.1 404 Not Found</status>
+      </propstat>
+    </response>
+  </multistatus>`;
+
+  let bytes = new TextEncoder().encode(res);
+  let str = "";
+  for (let i = 0; i < bytes.length; i += 65536) {
+    str += String.fromCharCode.apply(null, bytes.subarray(i, i + 65536));
+  }
+  response.write(str);
+}
diff --git a/comm/calendar/test/browser/data/dns.sjs b/comm/calendar/test/browser/data/dns.sjs
new file mode 100644
index 0000000000..85b8777233
--- /dev/null
+++ b/comm/calendar/test/browser/data/dns.sjs
@@ -0,0 +1,56 @@
+/* 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 handleRequest(request, response) {
+  if (!request.hasHeader("Authorization")) {
+    response.setStatusLine("1.1", 401, "Unauthorized");
+    response.setHeader("WWW-Authenticate", `Basic realm="test"`);
+    return;
+  }
+
+  response.setStatusLine("1.1", 207, "Multi-Status");
+  response.setHeader("Content-Type", "text/xml", false);
+
+  // Request:
+  // <propfind>
+  //   <prop>
+  //     <resourcetype/>
+  //     <owner/>
+  //     <displayname/>
+  //     <current-user-principal/>
+  //     <current-user-privilege-set/>
+  //     <calendar-color/>
+  //     <calendar-home-set/>
+  //   </prop>
+  // </propfind>
+
+  response.write(`<multistatus xmlns="DAV:"
+                               xmlns:A="http://apple.com/ns/ical/"
+                               xmlns:C="urn:ietf:params:xml:ns:caldav">
+    <response>
+      <href>/browser/comm/calendar/test/browser/data/dns.sjs</href>
+      <propstat>
+        <prop>
+          <resourcetype>
+            <collection/>
+          </resourcetype>
+          <current-user-principal>
+            <href>/browser/comm/calendar/test/browser/data/principal.sjs</href>
+          </current-user-principal>
+        </prop>
+        <status>HTTP/1.1 200 OK</status>
+      </propstat>
+      <propstat>
+        <prop>
+          <owner/>
+          <displayname/>
+          <current-user-privilege-set/>
+          <A:calendar-color/>
+          <C:calendar-home-set/>
+        </prop>
+        <status>HTTP/1.1 404 Not Found</status>
+      </propstat>
+    </response>
+  </multistatus>`);
+}
diff --git a/comm/calendar/test/browser/data/event.ics b/comm/calendar/test/browser/data/event.ics
new file mode 100644
index 0000000000..3ee7fd4495
--- /dev/null
+++ b/comm/calendar/test/browser/data/event.ics
@@ -0,0 +1,10 @@
+BEGIN:VCALENDAR

+PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN

+VERSION:2.0

+BEGIN:VEVENT

+SUMMARY:An Event

+DESCRIPTION:Parking is not available.

+DTSTART:20210325T110000Z

+DTEND:20210325T120000Z

+END:VEVENT

+END:VCALENDAR

diff --git a/comm/calendar/test/browser/data/import.ics b/comm/calendar/test/browser/data/import.ics
new file mode 100644
index 0000000000..b6e7a965d7
--- /dev/null
+++ b/comm/calendar/test/browser/data/import.ics
@@ -0,0 +1,24 @@
+BEGIN:VCALENDAR

+PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN

+VERSION:2.0

+BEGIN:VEVENT

+SUMMARY:Event One

+DTSTART:20190101T150000

+DTEND:20190101T160000

+END:VEVENT

+BEGIN:VEVENT

+SUMMARY:Event Four

+DTSTART:20190101T180000

+DTEND:20190101T190000

+END:VEVENT

+BEGIN:VEVENT

+SUMMARY:Event Three

+DTSTART:20190101T170000

+DTEND:20190101T180000

+END:VEVENT

+BEGIN:VEVENT

+SUMMARY:Event Two

+DTSTART:20190101T160000

+DTEND:20190101T170000

+END:VEVENT

+END:VCALENDAR

diff --git a/comm/calendar/test/browser/data/principal.sjs b/comm/calendar/test/browser/data/principal.sjs
new file mode 100644
index 0000000000..4cebd9660e
--- /dev/null
+++ b/comm/calendar/test/browser/data/principal.sjs
@@ -0,0 +1,39 @@
+/* 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 handleRequest(request, response) {
+  if (!request.hasHeader("Authorization")) {
+    response.setStatusLine("1.1", 401, "Unauthorized");
+    response.setHeader("WWW-Authenticate", `Basic realm="test"`);
+    return;
+  }
+
+  response.setStatusLine("1.1", 207, "Multi-Status");
+  response.setHeader("Content-Type", "text/xml", false);
+
+  // Request:
+  // <propfind>
+  //   <prop>
+  //     <resourcetype/>
+  //     <calendar-home-set/>
+  //   </prop>
+  // </propfind>
+
+  response.write(`<multistatus xmlns="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav">
+    <response>
+      <href>/browser/comm/calendar/test/browser/data/principal.sjs</href>
+      <propstat>
+        <prop>
+          <resourcetype>
+            <principal/>
+          </resourcetype>
+          <C:calendar-home-set>
+            <href>/browser/comm/calendar/test/browser/data/calendars.sjs</href>
+          </C:calendar-home-set>
+        </prop>
+        <status>HTTP/1.1 200 OK</status>
+      </propstat>
+    </response>
+  </multistatus>`);
+}
diff --git a/comm/calendar/test/browser/eventDialog/browser.ini b/comm/calendar/test/browser/eventDialog/browser.ini
new file mode 100644
index 0000000000..85f569c0cc
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser.ini
@@ -0,0 +1,27 @@
+[default]
+head = head.js
+prefs =
+  calendar.item.promptDelete=false
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+  calendar.week.start=0
+  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
+support-files = data/**
+
+[browser_alarmDialog.js]
+[browser_attachMenu.js]
+[browser_attendeesDialog.js]
+[browser_attendeesDialogAdd.js]
+[browser_attendeesDialogNoEdit.js]
+[browser_attendeesDialogRemove.js]
+[browser_attendeesDialogUpdate.js]
+[browser_eventDialog.js]
+[browser_eventDialogDescriptionEditor.js]
+[browser_eventDialogEditButton.js]
+[browser_eventDialogModificationPrompt.js]
+[browser_utf8.js]
diff --git a/comm/calendar/test/browser/eventDialog/browser_alarmDialog.js b/comm/calendar/test/browser/eventDialog/browser_alarmDialog.js
new file mode 100644
index 0000000000..0d6a07a3c4
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_alarmDialog.js
@@ -0,0 +1,88 @@
+/* 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 { saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { dayView } = CalendarTestUtils;
+
+add_task(async function testAlarmDialog() {
+  let now = new Date();
+
+  const TITLE = "Event";
+
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(
+    window,
+    now.getUTCFullYear(),
+    now.getUTCMonth() + 1,
+    now.getUTCDate()
+  );
+  await CalendarTestUtils.calendarViewForward(window, 1);
+
+  let allDayHeader = dayView.getAllDayHeader(window);
+  Assert.ok(allDayHeader);
+  EventUtils.synthesizeMouseAtCenter(allDayHeader, {}, window);
+
+  // Create a new all-day event tomorrow.
+
+  // Prepare to dismiss the alarm.
+  let alarmPromise = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-alarm-dialog.xhtml",
+    {
+      async callback(alarmWindow) {
+        await new Promise(resolve => alarmWindow.setTimeout(resolve, 500));
+
+        let dismissButton = alarmWindow.document.getElementById("alarm-dismiss-all-button");
+        EventUtils.synthesizeMouseAtCenter(dismissButton, {}, alarmWindow);
+      },
+    }
+  );
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window);
+  await setData(dialogWindow, iframeWindow, {
+    allday: true,
+    reminder: "1day",
+    title: TITLE,
+  });
+
+  await saveAndCloseItemDialog(dialogWindow);
+  await alarmPromise;
+
+  // Change the reminder duration, this resets the alarm.
+  let eventBox = await dayView.waitForAllDayItemAt(window, 1);
+
+  // Prepare to snooze the alarm.
+  alarmPromise = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-alarm-dialog.xhtml",
+    {
+      async callback(alarmWindow) {
+        await new Promise(resolve => alarmWindow.setTimeout(resolve, 500));
+
+        let snoozeAllButton = alarmWindow.document.getElementById("alarm-snooze-all-button");
+        let popup = alarmWindow.document.querySelector("#alarm-snooze-all-popup");
+        let menuitems = alarmWindow.document.querySelectorAll("#alarm-snooze-all-popup > menuitem");
+
+        let shownPromise = BrowserTestUtils.waitForEvent(snoozeAllButton, "popupshown");
+        EventUtils.synthesizeMouseAtCenter(snoozeAllButton, {}, alarmWindow);
+        await shownPromise;
+        popup.activateItem(menuitems[5]);
+      },
+    }
+  );
+
+  ({ dialogWindow, iframeWindow } = await CalendarTestUtils.editItem(window, eventBox));
+  await setData(dialogWindow, iframeWindow, { reminder: "2days", title: TITLE });
+  await saveAndCloseItemDialog(dialogWindow);
+  await alarmPromise;
+
+  Assert.ok(true, "Test ran to completion");
+});
diff --git a/comm/calendar/test/browser/eventDialog/browser_attachMenu.js b/comm/calendar/test/browser/eventDialog/browser_attachMenu.js
new file mode 100644
index 0000000000..2a0b2afc4c
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_attachMenu.js
@@ -0,0 +1,266 @@
+/* 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/. */
+
+/**
+ * Tests for the attach menu in the event dialog window.
+ */
+
+const { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+const { cloudFileAccounts } = ChromeUtils.import("resource:///modules/cloudFileAccounts.jsm");
+const { MockFilePicker } = ChromeUtils.importESModule(
+  "resource://testing-common/MockFilePicker.sys.mjs"
+);
+var { saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+// Remove the save prompt observer that head.js added. It's causing trouble here.
+Services.ww.unregisterNotification(savePromptObserver);
+
+let calendar = CalendarTestUtils.createCalendar("Attachments");
+registerCleanupFunction(() => {
+  cal.manager.unregisterCalendar(calendar);
+  MockFilePicker.cleanup();
+});
+
+async function getEventBox(selector) {
+  let itemBox;
+  await TestUtils.waitForCondition(() => {
+    itemBox = document.querySelector(selector);
+    return itemBox != null;
+  }, "calendar item did not appear in time");
+  return itemBox;
+}
+
+async function openEventFromBox(eventBox) {
+  if (Services.focus.activeWindow != window) {
+    await BrowserTestUtils.waitForEvent(window, "focus");
+  }
+  let promise = CalendarTestUtils.waitForEventDialog();
+  EventUtils.synthesizeMouseAtCenter(eventBox, { clickCount: 2 });
+  return promise;
+}
+
+/**
+ * Tests using the "Website" menu item attaches a link to the event.
+ */
+add_task(async function testAttachWebPage() {
+  let startDate = cal.createDateTime("20200101T000001Z");
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(startDate);
+
+  let { dialogWindow, iframeWindow, dialogDocument, iframeDocument } =
+    await CalendarTestUtils.editNewEvent(window);
+
+  await setData(dialogWindow, iframeWindow, {
+    title: "Web Link Event",
+    startDate,
+  });
+
+  // Attach the url.
+  let attachButton = dialogWindow.document.querySelector("#button-url");
+  Assert.ok(attachButton, "attach menu button found");
+
+  let menu = dialogDocument.querySelector("#button-attach-menupopup");
+  let menuShowing = BrowserTestUtils.waitForEvent(menu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(attachButton, {}, dialogWindow);
+  await menuShowing;
+
+  let url = "https://thunderbird.net/";
+  let urlPrompt = BrowserTestUtils.promiseAlertDialogOpen(
+    "",
+    "chrome://global/content/commonDialog.xhtml",
+    {
+      async callback(win) {
+        win.document.querySelector("#loginTextbox").value = url;
+        EventUtils.synthesizeKey("VK_RETURN", {}, win);
+      },
+    }
+  );
+  EventUtils.synthesizeMouseAtCenter(
+    dialogDocument.querySelector("#button-attach-url"),
+    {},
+    dialogWindow
+  );
+  await urlPrompt;
+
+  // Now check that the url shows in the attachments list.
+  EventUtils.synthesizeMouseAtCenter(
+    iframeDocument.querySelector("#event-grid-tab-attachments"),
+    {},
+    iframeWindow
+  );
+
+  let listBox = iframeDocument.querySelector("#attachment-link");
+  await BrowserTestUtils.waitForCondition(
+    () => listBox.itemChildren.length == 1,
+    "attachment list did not show in time"
+  );
+
+  Assert.equal(listBox.itemChildren[0].tooltipText, url, "url included in attachments list");
+
+  // Save the new event.
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Open the event to verify the attachment is shown in the summary dialog.
+  let summaryWin = await openEventFromBox(await getEventBox("calendar-month-day-box-item"));
+  let label = summaryWin.document.querySelector(`label[value="${url}"]`);
+  Assert.ok(label, "attachment label found on calendar summary dialog");
+  await BrowserTestUtils.closeWindow(summaryWin);
+
+  // Clean up.
+  let eventBox = await getEventBox("calendar-month-day-box-item");
+  eventBox.focus();
+  EventUtils.synthesizeKey("VK_DELETE", {});
+});
+
+/**
+ * Tests selecting a provider from the attach menu works.
+ */
+add_task(async function testAttachProvider() {
+  let fileUrl = "https://path/to/mock/file.pdf";
+  let iconURL = "chrome://messenger/content/extension.svg";
+  let provider = {
+    type: "Mochitest",
+    displayName: "Mochitest",
+    iconURL,
+    initAccount(accountKey) {
+      return {
+        accountKey,
+        type: "Mochitest",
+        get displayName() {
+          return Services.prefs.getCharPref(
+            `mail.cloud_files.accounts.${this.accountKey}.displayName`,
+            "Mochitest Account"
+          );
+        },
+        iconURL,
+        configured: true,
+        managementURL: "",
+        uploadFile(window, aFile) {
+          return new Promise(resolve =>
+            setTimeout(() =>
+              resolve({
+                id: 1,
+                path: aFile.path,
+                size: aFile.fileSize,
+                url: fileUrl,
+                // The uploadFile() function should return serviceIcon, serviceName
+                // and serviceUrl - either default or user defined values specified
+                // by the onFileUpload event. The item-edit dialog uses only the
+                // serviceIcon.
+                serviceIcon: "chrome://messenger/skin/icons/globe.svg",
+              })
+            )
+          );
+        },
+      };
+    },
+  };
+
+  cloudFileAccounts.registerProvider("Mochitest", provider);
+  cloudFileAccounts.createAccount("Mochitest");
+  registerCleanupFunction(() => {
+    cloudFileAccounts.unregisterProvider("Mochitest");
+  });
+
+  let file = new FileUtils.File(getTestFilePath("data/guests.txt"));
+  MockFilePicker.init(window);
+  MockFilePicker.setFiles([file]);
+  MockFilePicker.returnValue = MockFilePicker.returnOk;
+
+  let startDate = cal.createDateTime("20200201T000001Z");
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(startDate);
+
+  let { dialogWindow, iframeWindow, dialogDocument, iframeDocument } =
+    await CalendarTestUtils.editNewEvent(window);
+
+  await setData(dialogWindow, iframeWindow, {
+    title: "Provider Attachment Event",
+    startDate,
+  });
+
+  let attachButton = dialogDocument.querySelector("#button-url");
+  Assert.ok(attachButton, "attach menu button found");
+
+  let menu = dialogDocument.querySelector("#button-attach-menupopup");
+  let menuItem;
+
+  await BrowserTestUtils.waitForCondition(() => {
+    menuItem = menu.querySelector("menuitem[label='File using Mochitest Account']");
+    return menuItem;
+  });
+
+  Assert.ok(menuItem, "custom provider menuitem found");
+  Assert.equal(menuItem.image, iconURL, "provider image src is provider image");
+
+  // Click on the "Attach" menu.
+  let menuShowing = BrowserTestUtils.waitForEvent(menu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(attachButton, {}, dialogWindow);
+  await menuShowing;
+
+  // Click on the menuitem to attach a file using our provider.
+  let menuHidden = BrowserTestUtils.waitForEvent(menu, "popuphidden");
+  EventUtils.synthesizeMouseAtCenter(menuItem, {}, dialogWindow);
+  await menuHidden;
+
+  // Check if the file dialog was "shown". MockFilePicker.open() is asynchronous
+  // but does not return a promise.
+  await BrowserTestUtils.waitForCondition(
+    () => MockFilePicker.shown,
+    "file picker was not shown in time"
+  );
+
+  // Click on the attachments tab of the event dialog.
+  EventUtils.synthesizeMouseAtCenter(
+    iframeDocument.querySelector("#event-grid-tab-attachments"),
+    {},
+    iframeWindow
+  );
+
+  // Wait until the file we attached appears.
+  let listBox = iframeDocument.querySelector("#attachment-link");
+  await BrowserTestUtils.waitForCondition(
+    () => listBox.itemChildren.length == 1,
+    "attachment list did not show in time"
+  );
+
+  let listItem = listBox.itemChildren[0];
+
+  // XXX: This property is set after an async operation. Unfortunately, that
+  // operation is not awaited on in its surrounding code so the assertion
+  // after this will occasionally fail if this is not done.
+  await BrowserTestUtils.waitForCondition(
+    () => listItem.attachCloudFileUpload,
+    "attachCloudFileUpload property not set on attachment listitem in time."
+  );
+
+  Assert.equal(listItem.attachCloudFileUpload.url, fileUrl, "upload attached to event");
+
+  let listItemImage = listItem.querySelector("img");
+  Assert.equal(
+    listItemImage.src,
+    "chrome://messenger/skin/icons/globe.svg",
+    "attachment image is provider image"
+  );
+
+  // Save the new event.
+  dialogDocument.querySelector("#button-saveandclose").click();
+
+  // Open it and verify the attachment is shown.
+  let summaryWin = await openEventFromBox(await getEventBox("calendar-month-day-box-item"));
+  let label = summaryWin.document.querySelector(`label[value="${fileUrl}"]`);
+  Assert.ok(label, "attachment label found on calendar summary dialog");
+  await BrowserTestUtils.closeWindow(summaryWin);
+
+  if (Services.focus.activeWindow != window) {
+    await BrowserTestUtils.waitForEvent(window, "focus");
+  }
+
+  // Clean up.
+  let eventBox = await getEventBox("calendar-month-day-box-item");
+  eventBox.focus();
+  EventUtils.synthesizeKey("VK_DELETE", {});
+});
diff --git a/comm/calendar/test/browser/eventDialog/browser_attendeesDialog.js b/comm/calendar/test/browser/eventDialog/browser_attendeesDialog.js
new file mode 100644
index 0000000000..f6e73f3957
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_attendeesDialog.js
@@ -0,0 +1,462 @@
+/* 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/. */
+
+/* globals createEventWithDialog, openAttendeesWindow, closeAttendeesWindow */
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+add_task(async () => {
+  let calendar = CalendarTestUtils.createCalendar("Mochitest", "memory");
+  calendar.name = "Mochitest";
+  calendar.setProperty("organizerId", "mailto:mochitest@example.com");
+
+  cal.freeBusyService.addProvider(freeBusyProvider);
+
+  let book = MailServices.ab.getDirectoryFromId(
+    MailServices.ab.newAddressBook("Mochitest", null, 101)
+  );
+  let contacts = {};
+  for (let name of ["Charlie", "Juliet", "Mike", "Oscar", "Romeo", "Victor"]) {
+    let card = Cc["@mozilla.org/addressbook/cardproperty;1"].createInstance(Ci.nsIAbCard);
+    card.firstName = name;
+    card.lastName = "Mochitest";
+    card.displayName = `${name} Mochitest`;
+    card.primaryEmail = `${name.toLowerCase()}@example.com`;
+    contacts[name.toUpperCase()] = book.addCard(card);
+  }
+  let list = Cc["@mozilla.org/addressbook/directoryproperty;1"].createInstance(Ci.nsIAbDirectory);
+  list.isMailList = true;
+  list.dirName = "The Boys";
+  list = book.addMailList(list);
+  list.addCard(contacts.MIKE);
+  list.addCard(contacts.OSCAR);
+  list.addCard(contacts.ROMEO);
+  list.addCard(contacts.VICTOR);
+
+  let today = new Date();
+  let times = {
+    ONE: new Date(
+      Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate() + 1, 13, 0, 0)
+    ),
+    TWO_THIRTY: new Date(
+      Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate() + 1, 14, 30, 0)
+    ),
+    THREE_THIRTY: new Date(
+      Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate() + 1, 15, 30, 0)
+    ),
+    FOUR: new Date(
+      Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate() + 1, 16, 0, 0)
+    ),
+  };
+
+  registerCleanupFunction(async () => {
+    CalendarTestUtils.removeCalendar(calendar);
+    cal.freeBusyService.removeProvider(freeBusyProvider);
+    MailServices.ab.deleteAddressBook(book.URI);
+  });
+
+  let eventWindow = await openEventWindow(calendar);
+  let eventDocument = eventWindow.document;
+  let iframeDocument = eventDocument.getElementById("calendar-item-panel-iframe").contentDocument;
+
+  let eventStartTime = iframeDocument.getElementById("event-starttime");
+  eventStartTime.value = times.ONE;
+  let eventEndTime = iframeDocument.getElementById("event-endtime");
+  eventEndTime.value = times.THREE_THIRTY;
+
+  async function checkAttendeesInAttendeesDialog(attendeesDocument, expectedAttendees) {
+    let attendeesList = attendeesDocument.getElementById("attendee-list");
+    await TestUtils.waitForCondition(
+      () => attendeesList.childElementCount == expectedAttendees.length + 1,
+      "empty attendee input should have been added"
+    );
+
+    function getInputValueFromAttendeeRow(row) {
+      const input = row.querySelector("input");
+      return input.value;
+    }
+
+    Assert.deepEqual(
+      Array.from(attendeesList.children, getInputValueFromAttendeeRow),
+      [...expectedAttendees, ""],
+      "attendees list matches what was expected"
+    );
+    Assert.equal(
+      attendeesDocument.activeElement,
+      attendeesList.children[expectedAttendees.length].querySelector("input"),
+      "empty attendee input should have focus"
+    );
+  }
+
+  async function checkFreeBusy(row, count) {
+    Assert.equal(row._freeBusyDiv.querySelectorAll(".pending").length, 1);
+    Assert.equal(row._freeBusyDiv.querySelectorAll(".busy").length, 0);
+    let responsePromise = BrowserTestUtils.waitForEvent(row, "freebusy-update-finished");
+    freeBusyProvider.sendNextResponse();
+    await responsePromise;
+    Assert.equal(row._freeBusyDiv.querySelectorAll(".pending").length, 0);
+    Assert.equal(row._freeBusyDiv.querySelectorAll(".busy").length, count);
+  }
+
+  {
+    info("Opening for the first time");
+    let attendeesWindow = await openAttendeesWindow(eventWindow);
+    let attendeesDocument = attendeesWindow.document;
+    let attendeesList = attendeesDocument.getElementById("attendee-list");
+
+    Assert.equal(attendeesWindow.arguments[0].calendar, calendar);
+    Assert.equal(attendeesWindow.arguments[0].organizer, null);
+    Assert.equal(calendar.getProperty("organizerId"), "mailto:mochitest@example.com");
+    Assert.deepEqual(attendeesWindow.arguments[0].attendees, []);
+
+    await new Promise(resolve => attendeesWindow.setTimeout(resolve));
+
+    let attendeesStartTime = attendeesDocument.getElementById("event-starttime");
+    let attendeesEndTime = attendeesDocument.getElementById("event-endtime");
+    Assert.equal(attendeesStartTime.value.toISOString(), times.ONE.toISOString());
+    Assert.equal(attendeesEndTime.value.toISOString(), times.THREE_THIRTY.toISOString());
+
+    attendeesStartTime.value = times.TWO_THIRTY;
+    attendeesEndTime.value = times.FOUR;
+
+    // Check free/busy of organizer.
+
+    await checkAttendeesInAttendeesDialog(attendeesDocument, ["mochitest@example.com"]);
+
+    let organizer = attendeesList.firstElementChild;
+    await checkFreeBusy(organizer, 5);
+
+    // Add attendee.
+
+    EventUtils.sendString("test@example.com", attendeesWindow);
+    EventUtils.synthesizeKey("VK_TAB", {}, attendeesWindow);
+
+    await checkAttendeesInAttendeesDialog(attendeesDocument, [
+      "mochitest@example.com",
+      "test@example.com",
+    ]);
+    await checkFreeBusy(attendeesList.children[1], 0);
+
+    // Add another attendee, from the address book.
+
+    let input = attendeesDocument.activeElement;
+    EventUtils.sendString("julie", attendeesWindow);
+    await new Promise(resolve => attendeesWindow.setTimeout(resolve, 1000));
+    Assert.equal(input.value, "juliet Mochitest <juliet@example.com>");
+    Assert.ok(input.popupElement.popupOpen);
+    Assert.equal(input.popupElement.richlistbox.childElementCount, 1);
+    Assert.equal(input.popupElement._currentIndex, 1);
+    EventUtils.synthesizeKey("VK_DOWN", {}, attendeesWindow);
+    Assert.equal(input.popupElement._currentIndex, 1);
+    EventUtils.synthesizeKey("VK_TAB", {}, attendeesWindow);
+
+    await checkAttendeesInAttendeesDialog(attendeesDocument, [
+      "mochitest@example.com",
+      "test@example.com",
+      "Juliet Mochitest <juliet@example.com>",
+    ]);
+    await checkFreeBusy(attendeesList.children[2], 1);
+
+    // Add a mailing list which should expand.
+
+    input = attendeesDocument.activeElement;
+    EventUtils.sendString("boys", attendeesWindow);
+    await new Promise(resolve => attendeesWindow.setTimeout(resolve, 1000));
+    Assert.equal(input.value, "boys >> The Boys <The Boys>");
+    Assert.ok(input.popupElement.popupOpen);
+    Assert.equal(input.popupElement.richlistbox.childElementCount, 1);
+    Assert.equal(input.popupElement._currentIndex, 1);
+    EventUtils.synthesizeKey("VK_DOWN", {}, attendeesWindow);
+    Assert.equal(input.popupElement._currentIndex, 1);
+    EventUtils.synthesizeKey("VK_TAB", {}, attendeesWindow);
+
+    await checkAttendeesInAttendeesDialog(attendeesDocument, [
+      "mochitest@example.com",
+      "test@example.com",
+      "Juliet Mochitest <juliet@example.com>",
+      "Mike Mochitest <mike@example.com>",
+      "Oscar Mochitest <oscar@example.com>",
+      "Romeo Mochitest <romeo@example.com>",
+      "Victor Mochitest <victor@example.com>",
+    ]);
+    await checkFreeBusy(attendeesList.children[3], 0);
+    await checkFreeBusy(attendeesList.children[4], 0);
+    await checkFreeBusy(attendeesList.children[5], 1);
+    await checkFreeBusy(attendeesList.children[6], 0);
+
+    await closeAttendeesWindow(attendeesWindow);
+    await new Promise(resolve => eventWindow.setTimeout(resolve));
+  }
+
+  Assert.equal(eventStartTime.value.toISOString(), times.TWO_THIRTY.toISOString());
+  Assert.equal(eventEndTime.value.toISOString(), times.FOUR.toISOString());
+
+  function checkAttendeesInEventDialog(organizer, expectedAttendees) {
+    Assert.equal(iframeDocument.getElementById("item-organizer-row").textContent, organizer);
+
+    let attendeeItems = iframeDocument.querySelectorAll(".attendee-list .attendee-label");
+    Assert.equal(attendeeItems.length, expectedAttendees.length);
+    for (let i = 0; i < expectedAttendees.length; i++) {
+      Assert.equal(attendeeItems[i].getAttribute("attendeeid"), expectedAttendees[i]);
+    }
+  }
+
+  checkAttendeesInEventDialog("mochitest@example.com", [
+    "mailto:mochitest@example.com",
+    "mailto:test@example.com",
+    "mailto:juliet@example.com",
+    "mailto:mike@example.com",
+    "mailto:oscar@example.com",
+    "mailto:romeo@example.com",
+    "mailto:victor@example.com",
+  ]);
+
+  {
+    info("Opening for a second time");
+    let attendeesWindow = await openAttendeesWindow(eventWindow);
+    let attendeesDocument = attendeesWindow.document;
+    let attendeesList = attendeesDocument.getElementById("attendee-list");
+
+    let attendeesStartTime = attendeesDocument.getElementById("event-starttime");
+    let attendeesEndTime = attendeesDocument.getElementById("event-endtime");
+    Assert.equal(attendeesStartTime.value.toISOString(), times.TWO_THIRTY.toISOString());
+    Assert.equal(attendeesEndTime.value.toISOString(), times.FOUR.toISOString());
+
+    await checkAttendeesInAttendeesDialog(attendeesDocument, [
+      "mochitest@example.com",
+      "test@example.com",
+      "Juliet Mochitest <juliet@example.com>",
+      "Mike Mochitest <mike@example.com>",
+      "Oscar Mochitest <oscar@example.com>",
+      "Romeo Mochitest <romeo@example.com>",
+      "Victor Mochitest <victor@example.com>",
+    ]);
+
+    await checkFreeBusy(attendeesList.children[0], 5);
+    await checkFreeBusy(attendeesList.children[1], 0);
+    await checkFreeBusy(attendeesList.children[2], 1);
+    await checkFreeBusy(attendeesList.children[3], 0);
+    await checkFreeBusy(attendeesList.children[4], 0);
+    await checkFreeBusy(attendeesList.children[5], 1);
+    await checkFreeBusy(attendeesList.children[6], 0);
+
+    await closeAttendeesWindow(attendeesWindow);
+    await new Promise(resolve => eventWindow.setTimeout(resolve));
+  }
+
+  Assert.equal(eventStartTime.value.toISOString(), times.TWO_THIRTY.toISOString());
+  Assert.equal(eventEndTime.value.toISOString(), times.FOUR.toISOString());
+
+  checkAttendeesInEventDialog("mochitest@example.com", [
+    "mailto:mochitest@example.com",
+    "mailto:test@example.com",
+    "mailto:juliet@example.com",
+    "mailto:mike@example.com",
+    "mailto:oscar@example.com",
+    "mailto:romeo@example.com",
+    "mailto:victor@example.com",
+  ]);
+
+  iframeDocument.getElementById("notify-attendees-checkbox").checked = false;
+  await closeEventWindow(eventWindow);
+});
+
+add_task(async () => {
+  let calendar = CalendarTestUtils.createCalendar("Mochitest", "memory");
+  calendar.setProperty("organizerId", "mailto:mochitest@example.com");
+
+  registerCleanupFunction(async () => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  let defaults = {
+    displayTimezone: true,
+    attendees: [],
+    organizer: null,
+    calendar,
+    onOk: () => {},
+  };
+
+  async function testDays(startTime, endTime, expectedFirst, expectedLast) {
+    let attendeesWindow = await openAttendeesWindow({ ...defaults, startTime, endTime });
+    let attendeesDocument = attendeesWindow.document;
+
+    let days = attendeesDocument.querySelectorAll("calendar-day");
+    Assert.equal(days.length, 16);
+    Assert.equal(days[0].date.icalString, expectedFirst);
+    Assert.equal(days[15].date.icalString, expectedLast);
+
+    await closeAttendeesWindow(attendeesWindow);
+  }
+
+  // With the management of the reduced days or not, the format of the dates is different according to the cases.
+  // In case of a reduced day, the day format will include the start hour of the day (defined by calendar.view.daystarthour).
+  // In the case of a full day, we keep the behavior similar to before.
+
+  //Full day tests
+  await testDays(
+    cal.createDateTime("20100403T020000"),
+    cal.createDateTime("20100403T030000"),
+    "20100403",
+    "20100418"
+  );
+  for (let i = -2; i < 0; i++) {
+    await testDays(
+      fromToday({ days: i, hours: 2 }),
+      fromToday({ days: i, hours: 3 }),
+      fromToday({ days: i }).icalString.substring(0, 8),
+      fromToday({ days: i + 15 }).icalString.substring(0, 8)
+    );
+  }
+  for (let i = 0; i < 3; i++) {
+    await testDays(
+      fromToday({ days: i, hours: 2 }),
+      fromToday({ days: i, hours: 3 }),
+      fromToday({ days: 0 }).icalString.substring(0, 8),
+      fromToday({ days: 15 }).icalString.substring(0, 8)
+    );
+  }
+  for (let i = 3; i < 5; i++) {
+    await testDays(
+      fromToday({ days: i, hours: 2 }),
+      fromToday({ days: i, hours: 3 }),
+      fromToday({ days: i - 2 }).icalString.substring(0, 8),
+      fromToday({ days: i + 13 }).icalString.substring(0, 8)
+    );
+  }
+  await testDays(
+    cal.createDateTime("20300403T020000"),
+    cal.createDateTime("20300403T030000"),
+    "20300401",
+    "20300416"
+  );
+
+  // Reduced day tests
+  let dayStartHour = Services.prefs.getIntPref("calendar.view.daystarthour", 8).toString();
+  if (dayStartHour.length == 1) {
+    dayStartHour = "0" + dayStartHour;
+  }
+
+  await testDays(
+    cal.createDateTime("20100403T120000"),
+    cal.createDateTime("20100403T130000"),
+    "20100403T" + dayStartHour + "0000Z",
+    "20100418T" + dayStartHour + "0000Z"
+  );
+  for (let i = -2; i < 0; i++) {
+    await testDays(
+      fromToday({ days: i, hours: 12 }),
+      fromToday({ days: i, hours: 13 }),
+      fromToday({ days: i }).icalString.substring(0, 8) + "T" + dayStartHour + "0000Z",
+      fromToday({ days: i + 15 }).icalString.substring(0, 8) + "T" + dayStartHour + "0000Z"
+    );
+  }
+  for (let i = 0; i < 3; i++) {
+    await testDays(
+      fromToday({ days: i, hours: 12 }),
+      fromToday({ days: i, hours: 13 }),
+      fromToday({ days: 0 }).icalString.substring(0, 8) + "T" + dayStartHour + "0000Z",
+      fromToday({ days: 15 }).icalString.substring(0, 8) + "T" + dayStartHour + "0000Z"
+    );
+  }
+  for (let i = 3; i < 5; i++) {
+    await testDays(
+      fromToday({ days: i, hours: 12 }),
+      fromToday({ days: i, hours: 13 }),
+      fromToday({ days: i - 2 }).icalString.substring(0, 8) + "T" + dayStartHour + "0000Z",
+      fromToday({ days: i + 13 }).icalString.substring(0, 8) + "T" + dayStartHour + "0000Z"
+    );
+  }
+  await testDays(
+    cal.createDateTime("20300403T120000"),
+    cal.createDateTime("20300403T130000"),
+    "20300401T" + dayStartHour + "0000Z",
+    "20300416T" + dayStartHour + "0000Z"
+  );
+});
+
+function openEventWindow(calendar) {
+  let eventWindowPromise = BrowserTestUtils.domWindowOpened(null, async win => {
+    await BrowserTestUtils.waitForEvent(win, "load");
+
+    let doc = win.document;
+    if (doc.documentURI == "chrome://calendar/content/calendar-event-dialog.xhtml") {
+      let iframe = doc.getElementById("calendar-item-panel-iframe");
+      await BrowserTestUtils.waitForEvent(iframe.contentWindow, "load");
+      return true;
+    }
+    return false;
+  });
+  createEventWithDialog(calendar, null, null, "Event");
+  return eventWindowPromise;
+}
+
+async function closeEventWindow(eventWindow) {
+  let eventWindowPromise = BrowserTestUtils.domWindowClosed(eventWindow);
+  eventWindow.document.getElementById("button-saveandclose").click();
+  await eventWindowPromise;
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+function fromToday({ days = 0, hours = 0 }) {
+  if (!fromToday.today) {
+    fromToday.today = cal.dtz.now();
+    fromToday.today.hour = fromToday.today.minute = fromToday.today.second = 0;
+  }
+
+  let duration = cal.createDuration();
+  duration.days = days;
+  duration.hours = hours;
+
+  let value = fromToday.today.clone();
+  value.addDuration(duration);
+  return value;
+}
+
+var freeBusyProvider = {
+  pendingRequests: [],
+  sendNextResponse() {
+    let next = this.pendingRequests.shift();
+    if (next) {
+      next();
+    }
+  },
+  getFreeBusyIntervals(aCalId, aStart, aEnd, aTypes, aListener) {
+    this.pendingRequests.push(() => {
+      info(`Sending free/busy response for ${aCalId}`);
+      if (aCalId in this.data) {
+        aListener.onResult(
+          null,
+          this.data[aCalId].map(([startDuration, duration]) => {
+            let start = fromToday(startDuration);
+
+            let end = start.clone();
+            end.addDuration(cal.createDuration(duration));
+
+            return new cal.provider.FreeBusyInterval(
+              aCalId,
+              Ci.calIFreeBusyInterval.BUSY,
+              start,
+              end
+            );
+          })
+        );
+      } else {
+        aListener.onResult(null, []);
+      }
+    });
+  },
+  data: {
+    "mailto:mochitest@example.com": [
+      [{ days: 1, hours: 4 }, "PT3H"],
+      [{ days: 1, hours: 8 }, "PT3H"],
+      [{ days: 1, hours: 12 }, "PT3H"],
+      [{ days: 1, hours: 16 }, "PT3H"],
+      [{ days: 2, hours: 4 }, "PT3H"],
+    ],
+    "mailto:juliet@example.com": [["P1DT9H", "PT8H"]],
+    "mailto:romeo@example.com": [["P1DT14H", "PT5H"]],
+  },
+};
diff --git a/comm/calendar/test/browser/eventDialog/browser_attendeesDialogAdd.js b/comm/calendar/test/browser/eventDialog/browser_attendeesDialogAdd.js
new file mode 100644
index 0000000000..c1f2778118
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_attendeesDialogAdd.js
@@ -0,0 +1,248 @@
+/* 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/. */
+
+/* globals openAttendeesWindow, closeAttendeesWindow, findAndEditMatchingRow */
+
+const { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+
+add_setup(async function () {
+  await CalendarTestUtils.setCalendarView(window, "day");
+  CalendarTestUtils.goToDate(window, 2023, 2, 18);
+});
+
+add_task(async function testAddAttendeeToEventWithNone() {
+  const calendar = CalendarTestUtils.createCalendar();
+  calendar.setProperty("organizerId", "mailto:foo@example.com");
+  calendar.setProperty("organizerCN", "Foo Fooson");
+
+  // Create an event which currently has no attendees or organizer.
+  const event = await calendar.addItem(
+    new CalEvent(CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      SUMMARY:An event
+      DTSTART:20230218T100000Z
+      DTEND:20230218T110000Z
+      END:VEVENT
+    `)
+  );
+
+  // Remember event details so we can refetch it after editing.
+  const eventId = event.id;
+  const eventModified = event.lastModifiedTime;
+
+  // Sanity check.
+  Assert.equal(event.organizer, null, "event should not have an organizer");
+  Assert.equal(event.getAttendees().length, 0, "event should not have any attendees");
+
+  // Open our event for editing.
+  const { dialogWindow: eventWindow } = await CalendarTestUtils.dayView.editEventAt(window, 1);
+  const attendeesWindow = await openAttendeesWindow(eventWindow);
+
+  // Set text in the empty row to create a new attendee.
+  findAndEditMatchingRow(
+    attendeesWindow,
+    "bar@example.com",
+    "there should an empty input",
+    value => value === ""
+  );
+
+  // Save and close the event.
+  await closeAttendeesWindow(attendeesWindow);
+  await CalendarTestUtils.items.saveAndCloseItemDialog(eventWindow);
+
+  await TestUtils.waitForCondition(async () => {
+    const item = await calendar.getItem(eventId);
+    return item.lastModifiedTime != eventModified;
+  });
+
+  const editedEvent = await calendar.getItem(eventId);
+
+  // Verify that the organizer was set on the event.
+  const organizer = editedEvent.organizer;
+  Assert.ok(organizer, "there should be an organizer for the event after editing");
+  Assert.equal(
+    organizer.id,
+    "mailto:foo@example.com",
+    "organizer ID should match calendar property"
+  );
+  Assert.equal(organizer.commonName, "Foo Fooson", "organizer name should match calendar property");
+
+  const attendees = editedEvent.getAttendees();
+  Assert.equal(attendees.length, 2, "there should be two attendees of the event after editing");
+
+  // Verify that the organizer was added as an attendee.
+  const fooFooson = attendees.find(attendee => attendee.id == "mailto:foo@example.com");
+  Assert.ok(fooFooson, "the organizer should have been added as an attendee");
+  Assert.equal(fooFooson.commonName, "Foo Fooson", "attendee name should match organizer's");
+  Assert.equal(
+    fooFooson.participationStatus,
+    "ACCEPTED",
+    "organizer attendee should have automatically accepted"
+  );
+  Assert.equal(fooFooson.role, "REQ-PARTICIPANT", "organizer attendee should be required");
+
+  // Verify that the attendee we added to the list is represented on the event.
+  const barBarrington = attendees.find(attendee => attendee.id == "mailto:bar@example.com");
+  Assert.ok(barBarrington, "an attendee should have the address bar@example.com");
+  Assert.equal(barBarrington.commonName, null, "new attendee name should not be set");
+  Assert.equal(
+    barBarrington.participationStatus,
+    "NEEDS-ACTION",
+    "new attendee should have default participation status"
+  );
+  Assert.equal(barBarrington.role, "REQ-PARTICIPANT", "new attendee should have default role");
+
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+add_task(async function testAddAttendeeToEventWithoutOrganizerAsAttendee() {
+  const calendar = CalendarTestUtils.createCalendar();
+  calendar.setProperty("organizerId", "mailto:foo@example.com");
+  calendar.setProperty("organizerCN", "Foo Fooson");
+
+  // Create an event which has an organizer and attendees, but no attendee
+  // matching the organizer.
+  const event = await calendar.addItem(
+    new CalEvent(CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      SUMMARY:An event
+      DTSTART:20230218T100000Z
+      DTEND:20230218T110000Z
+      ORGANIZER;CN="Foo Fooson":mailto:foo@example.com
+      ATTENDEE;CN="Bar Barrington";PARTSTAT=DECLINED;ROLE=CHAIR:mailto:bar@examp
+       le.com
+      ATTENDEE;CN="Baz Luhrmann";PARTSTAT=NEEDS-ACTION;ROLE=OPT-PARTICIPANT;RSV
+       P=TRUE:mailto:baz@example.com
+      END:VEVENT
+    `)
+  );
+
+  // Remember event details so we can refetch it after editing.
+  const eventId = event.id;
+  const eventModified = event.lastModifiedTime;
+
+  // Sanity check. Note that order of attendees is not significant and thus not
+  // guaranteed.
+  const organizer = event.organizer;
+  Assert.ok(organizer, "the organizer should be set");
+  Assert.equal(organizer.id, "mailto:foo@example.com", "organizer ID should match");
+  Assert.equal(organizer.commonName, "Foo Fooson", "organizer name should match");
+
+  const attendees = event.getAttendees();
+  Assert.equal(attendees.length, 2, "there should be two attendees of the event");
+
+  const fooFooson = attendees.find(attendee => attendee.id == "mailto:foo@example.com");
+  Assert.ok(!fooFooson, "there should be no attendee matching the organizer");
+
+  const barBarrington = attendees.find(attendee => attendee.id == "mailto:bar@example.com");
+  Assert.ok(barBarrington, "an attendee should have the address bar@example.com");
+  Assert.equal(barBarrington.commonName, "Bar Barrington", "attendee name should match");
+  Assert.equal(barBarrington.participationStatus, "DECLINED", "attendee should have declined");
+  Assert.equal(barBarrington.role, "CHAIR", "attendee should be the meeting chair");
+
+  const bazLuhrmann = attendees.find(attendee => attendee.id == "mailto:baz@example.com");
+  Assert.ok(bazLuhrmann, "an attendee should have the address baz@example.com");
+  Assert.equal(bazLuhrmann.commonName, "Baz Luhrmann", "attendee name should match");
+  Assert.equal(
+    bazLuhrmann.participationStatus,
+    "NEEDS-ACTION",
+    "attendee should not have responded yet"
+  );
+  Assert.equal(bazLuhrmann.role, "OPT-PARTICIPANT", "attendee should be optional");
+  Assert.equal(bazLuhrmann.rsvp, "TRUE", "attendee should be expected to RSVP");
+
+  // Open our event for editing.
+  const { dialogWindow: eventWindow } = await CalendarTestUtils.dayView.editEventAt(window, 1);
+  const attendeesWindow = await openAttendeesWindow(eventWindow);
+
+  // Verify that we don't display an attendee for the organizer if there is no
+  // attendee on the event for them.
+  const attendeeList = attendeesWindow.document.getElementById("attendee-list");
+  const attendeeInput = Array.from(attendeeList.children)
+    .map(child => child.querySelector("input"))
+    .find(input => {
+      return input ? input.value.includes("foo@example.com") : false;
+    });
+  Assert.ok(!attendeeInput, "there should be no row in the dialog for the organizer");
+
+  // Set text in the empty row to create a new attendee.
+  findAndEditMatchingRow(
+    attendeesWindow,
+    "Jim James <jim@example.com>",
+    "there should an empty input",
+    value => value === ""
+  );
+
+  // Save and close the event.
+  await closeAttendeesWindow(attendeesWindow);
+  await CalendarTestUtils.items.saveAndCloseItemDialog(eventWindow);
+
+  await TestUtils.waitForCondition(async () => {
+    const item = await calendar.getItem(eventId);
+    return item.lastModifiedTime != eventModified;
+  });
+
+  const editedEvent = await calendar.getItem(eventId);
+
+  // Verify that the organizer hasn't changed.
+  const editedOrganizer = editedEvent.organizer;
+  Assert.ok(editedOrganizer, "the organizer should still be set on the event after editing");
+  Assert.equal(
+    editedOrganizer.id,
+    "mailto:foo@example.com",
+    "organizer ID should not have changed"
+  );
+  Assert.equal(editedOrganizer.commonName, "Foo Fooson", "organizer name should not have changed");
+
+  const editedAttendees = editedEvent.getAttendees();
+  Assert.equal(
+    editedAttendees.length,
+    3,
+    "there should be three attendees of the event after editing"
+  );
+
+  // Verify that no attendee matching the organizer was added.
+  const editedFooFooson = editedAttendees.find(attendee => attendee.id == "mailto:foo@example.com");
+  Assert.ok(!editedFooFooson, "there should still be no attendee matching the organizer");
+
+  // Verify that a new attendee was added.
+  const jimJames = editedAttendees.find(attendee => attendee.id == "mailto:jim@example.com");
+  Assert.ok(jimJames, "an attendee should have the address jim@example.com");
+  Assert.equal(jimJames.commonName, "Jim James", "new attendee name should be set");
+  Assert.equal(
+    jimJames.participationStatus,
+    "NEEDS-ACTION",
+    "new attendee should have default participation status"
+  );
+  Assert.equal(jimJames.role, "REQ-PARTICIPANT", "new attendee should have default role");
+
+  // Verify that the original first attendee's properties remain untouched.
+  const editedBarBarrington = editedAttendees.find(
+    attendee => attendee.id == "mailto:bar@example.com"
+  );
+  Assert.ok(editedBarBarrington, "an attendee should have the address bar@example.com");
+  Assert.equal(editedBarBarrington.commonName, "Bar Barrington", "attendee name should match");
+  Assert.equal(
+    editedBarBarrington.participationStatus,
+    "DECLINED",
+    "attendee should have declined"
+  );
+  Assert.equal(editedBarBarrington.role, "CHAIR", "attendee should be the meeting chair");
+
+  // Verify that the original second attendee's properties remain untouched.
+  const editedBazLuhrmann = editedAttendees.find(
+    attendee => attendee.id == "mailto:baz@example.com"
+  );
+  Assert.ok(editedBazLuhrmann, "an attendee should have the address baz@example.com");
+  Assert.equal(editedBazLuhrmann.commonName, "Baz Luhrmann", "attendee name should match");
+  Assert.equal(
+    editedBazLuhrmann.participationStatus,
+    "NEEDS-ACTION",
+    "attendee should not have responded yet"
+  );
+  Assert.equal(editedBazLuhrmann.role, "OPT-PARTICIPANT", "attendee should be optional");
+  Assert.equal(editedBazLuhrmann.rsvp, "TRUE", "attendee should be expected to RSVP");
+
+  CalendarTestUtils.removeCalendar(calendar);
+});
diff --git a/comm/calendar/test/browser/eventDialog/browser_attendeesDialogNoEdit.js b/comm/calendar/test/browser/eventDialog/browser_attendeesDialogNoEdit.js
new file mode 100644
index 0000000000..a103173790
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_attendeesDialogNoEdit.js
@@ -0,0 +1,68 @@
+/* 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/. */
+
+/* globals openAttendeesWindow, closeAttendeesWindow, findAndFocusMatchingRow */
+
+const { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+
+add_setup(async function () {
+  await CalendarTestUtils.setCalendarView(window, "day");
+  CalendarTestUtils.goToDate(window, 2023, 2, 18);
+});
+
+add_task(async function testBackingOutWithNoAttendees() {
+  const calendar = CalendarTestUtils.createCalendar();
+  calendar.setProperty("organizerId", "mailto:foo@example.com");
+  calendar.setProperty("organizerCN", "Foo Fooson");
+
+  // Create an event which currently has no attendees or organizer.
+  const event = await calendar.addItem(
+    new CalEvent(CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      SUMMARY:An event
+      DTSTART:20230218T100000Z
+      DTEND:20230218T110000Z
+      END:VEVENT
+    `)
+  );
+
+  // Remember event details so we can refetch it after editing.
+  const eventId = event.id;
+  const eventModified = event.lastModifiedTime;
+
+  // Sanity check.
+  Assert.equal(event.organizer, null, "event should not have an organizer");
+  Assert.equal(event.getAttendees().length, 0, "event should not have any attendees");
+
+  // Open our event for editing.
+  const { dialogWindow: eventWindow } = await CalendarTestUtils.dayView.editEventAt(window, 1);
+  const attendeesWindow = await openAttendeesWindow(eventWindow);
+
+  findAndFocusMatchingRow(attendeesWindow, "there should be a row matching the organizer", value =>
+    value.includes(calendar.getProperty("organizerCN"))
+  );
+
+  // We changed our mind. Save and close the event.
+  await closeAttendeesWindow(attendeesWindow);
+  await CalendarTestUtils.items.saveAndCloseItemDialog(eventWindow);
+
+  // The event is still counted as modified even with no changes. If this
+  // changes in the future, we'll just need to wait a reasonable time and fetch
+  // the event again.
+  await TestUtils.waitForCondition(async () => {
+    const item = await calendar.getItem(eventId);
+    return item.lastModifiedTime != eventModified;
+  });
+
+  const editedEvent = await calendar.getItem(eventId);
+
+  // Verify that the organizer was set on the event.
+  const organizer = editedEvent.organizer;
+  Assert.ok(!organizer, "there should still be no organizer for the event");
+
+  const attendees = editedEvent.getAttendees();
+  Assert.equal(attendees.length, 0, "there should still be no attendees of the event");
+
+  CalendarTestUtils.removeCalendar(calendar);
+});
diff --git a/comm/calendar/test/browser/eventDialog/browser_attendeesDialogRemove.js b/comm/calendar/test/browser/eventDialog/browser_attendeesDialogRemove.js
new file mode 100644
index 0000000000..7ad5a3cf68
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_attendeesDialogRemove.js
@@ -0,0 +1,147 @@
+/* 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/. */
+
+/* globals openAttendeesWindow, closeAttendeesWindow, findAndEditMatchingRow */
+
+const { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+
+add_setup(async function () {
+  await CalendarTestUtils.setCalendarView(window, "day");
+  CalendarTestUtils.goToDate(window, 2023, 2, 18);
+});
+
+add_task(async function testRemoveOrganizerAttendee() {
+  const calendar = CalendarTestUtils.createCalendar();
+  calendar.setProperty("organizerId", "mailto:jim@example.com");
+  calendar.setProperty("organizerCN", "Jim James");
+
+  // Create an event with several attendees, including one matching the current
+  // organizer.
+  const event = await calendar.addItem(
+    new CalEvent(CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      SUMMARY:An event
+      DTSTART:20230218T100000Z
+      DTEND:20230218T110000Z
+      ORGANIZER;CN="Foo Fooson":mailto:foo@example.com
+      ATTENDEE;CN="Foo Fooson";PARTSTAT=TENTATIVE;ROLE=REQ-PARTICIPANT:mailto:f
+       oo@example.com
+      ATTENDEE;CN="Bar Barrington";PARTSTAT=DECLINED;ROLE=CHAIR:mailto:bar@exam
+       ple.com
+      ATTENDEE;CN="Baz Luhrmann";PARTSTAT=NEEDS-ACTION;ROLE=OPT-PARTICIPANT;RSV
+       P=TRUE:mailto:baz@example.com
+      END:VEVENT
+    `)
+  );
+
+  // Remember event details so we can refetch it after editing.
+  const eventId = event.id;
+  const eventModified = event.lastModifiedTime;
+
+  // Sanity check. Note that order of attendees is not significant and thus not
+  // guaranteed.
+  const organizer = event.organizer;
+  Assert.ok(organizer, "the organizer should be set");
+  Assert.equal(organizer.id, "mailto:foo@example.com", "organizer ID should match");
+  Assert.equal(organizer.commonName, "Foo Fooson", "organizer name should match");
+
+  const attendees = event.getAttendees();
+  Assert.equal(attendees.length, 3, "there should be three attendees of the event");
+
+  const fooFooson = attendees.find(attendee => attendee.id == "mailto:foo@example.com");
+  Assert.ok(fooFooson, "an attendee should match the organizer");
+  Assert.equal(fooFooson.commonName, "Foo Fooson", "attendee name should match");
+  Assert.equal(fooFooson.participationStatus, "TENTATIVE", "attendee should be marked tentative");
+  Assert.equal(fooFooson.role, "REQ-PARTICIPANT", "attendee should be required");
+
+  const barBarrington = attendees.find(attendee => attendee.id == "mailto:bar@example.com");
+  Assert.ok(barBarrington, "an attendee should have the address bar@example.com");
+  Assert.equal(barBarrington.commonName, "Bar Barrington", "attendee name should match");
+  Assert.equal(barBarrington.participationStatus, "DECLINED", "attendee should have declined");
+  Assert.equal(barBarrington.role, "CHAIR", "attendee should be the meeting chair");
+
+  const bazLuhrmann = attendees.find(attendee => attendee.id == "mailto:baz@example.com");
+  Assert.ok(bazLuhrmann, "an attendee should have the address baz@example.com");
+  Assert.equal(bazLuhrmann.commonName, "Baz Luhrmann", "attendee name should match");
+  Assert.equal(
+    bazLuhrmann.participationStatus,
+    "NEEDS-ACTION",
+    "attendee should not have responded yet"
+  );
+  Assert.equal(bazLuhrmann.role, "OPT-PARTICIPANT", "attendee should be optional");
+  Assert.equal(bazLuhrmann.rsvp, "TRUE", "attendee should be expected to RSVP");
+
+  // Open our event for editing.
+  const { dialogWindow: eventWindow } = await CalendarTestUtils.dayView.editEventAt(window, 1);
+  const attendeesWindow = await openAttendeesWindow(eventWindow);
+
+  // Empty the row matching the organizer's attendee.
+  findAndEditMatchingRow(
+    attendeesWindow,
+    "",
+    "there should an input for attendee matching the organizer",
+    value => value.includes("foo@example.com")
+  );
+
+  // Save and close the event.
+  await closeAttendeesWindow(attendeesWindow);
+  await CalendarTestUtils.items.saveAndCloseItemDialog(eventWindow);
+
+  await TestUtils.waitForCondition(async () => {
+    const item = await calendar.getItem(eventId);
+    return item.lastModifiedTime != eventModified;
+  });
+
+  const editedEvent = await calendar.getItem(eventId);
+
+  // Verify that the organizer hasn't changed.
+  const editedOrganizer = editedEvent.organizer;
+  Assert.ok(editedOrganizer, "the organizer should still be set on the event after editing");
+  Assert.equal(
+    editedOrganizer.id,
+    "mailto:foo@example.com",
+    "organizer ID should not have changed"
+  );
+  Assert.equal(editedOrganizer.commonName, "Foo Fooson", "organizer name should not have changed");
+
+  const editedAttendees = editedEvent.getAttendees();
+  Assert.equal(
+    editedAttendees.length,
+    2,
+    "there should be two attendees of the event after editing"
+  );
+
+  // Verify that the attendee matching the organizer was removed.
+  const editedFooFooson = editedAttendees.find(attendee => attendee.id == "mailto:foo@example.com");
+  Assert.ok(!editedFooFooson, "there should be no attendee matching the organizer after editing");
+
+  // Verify that the second attendee's properties remain untouched.
+  const editedBarBarrington = editedAttendees.find(
+    attendee => attendee.id == "mailto:bar@example.com"
+  );
+  Assert.ok(editedBarBarrington, "an attendee should have the address bar@example.com");
+  Assert.equal(editedBarBarrington.commonName, "Bar Barrington", "attendee name should match");
+  Assert.equal(
+    editedBarBarrington.participationStatus,
+    "DECLINED",
+    "attendee should have declined"
+  );
+  Assert.equal(editedBarBarrington.role, "CHAIR", "attendee should be the meeting chair");
+
+  // Verify that the final attendee's properties remain untouched.
+  const editedBazLuhrmann = editedAttendees.find(
+    attendee => attendee.id == "mailto:baz@example.com"
+  );
+  Assert.ok(editedBazLuhrmann, "an attendee should have the address baz@example.com");
+  Assert.equal(editedBazLuhrmann.commonName, "Baz Luhrmann", "attendee name should match");
+  Assert.equal(
+    editedBazLuhrmann.participationStatus,
+    "NEEDS-ACTION",
+    "attendee should not have responded yet"
+  );
+  Assert.equal(editedBazLuhrmann.role, "OPT-PARTICIPANT", "attendee should be optional");
+  Assert.equal(editedBazLuhrmann.rsvp, "TRUE", "attendee should be expected to RSVP");
+
+  CalendarTestUtils.removeCalendar(calendar);
+});
diff --git a/comm/calendar/test/browser/eventDialog/browser_attendeesDialogUpdate.js b/comm/calendar/test/browser/eventDialog/browser_attendeesDialogUpdate.js
new file mode 100644
index 0000000000..b4e30344d0
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_attendeesDialogUpdate.js
@@ -0,0 +1,140 @@
+/* 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/. */
+
+/* globals openAttendeesWindow, closeAttendeesWindow, findAndEditMatchingRow */
+
+const { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+
+add_setup(async function () {
+  await CalendarTestUtils.setCalendarView(window, "day");
+  CalendarTestUtils.goToDate(window, 2023, 2, 18);
+});
+
+add_task(async function testUpdateAttendee() {
+  const calendar = CalendarTestUtils.createCalendar();
+  calendar.setProperty("organizerId", "mailto:foo@example.com");
+
+  // Create an event with several attendees, all of which should have some
+  // non-default properties which aren't covered in the attendees dialog to
+  // ensure that we aren't throwing properties away when we close the dialog.
+  const event = await calendar.addItem(
+    new CalEvent(CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      SUMMARY:An event
+      DTSTART:20230218T100000Z
+      DTEND:20230218T110000Z
+      ORGANIZER;CN="Foo Fooson":mailto:foo@example.com
+      ATTENDEE;CN="Foo Fooson";PARTSTAT=TENTATIVE;ROLE=REQ-PARTICIPANT:mailto:f
+       oo@example.com
+      ATTENDEE;CN="Bar Barington";PARTSTAT=DECLINED;ROLE=CHAIR:mailto:bar@examp
+       le.com
+      ATTENDEE;CN="Baz Luhrmann";PARTSTAT=NEEDS-ACTION;ROLE=OPT-PARTICIPANT;RSV
+       P=TRUE:mailto:baz@example.com
+      END:VEVENT
+    `)
+  );
+
+  // Remember event details so we can refetch it after editing.
+  const eventId = event.id;
+  const eventModified = event.lastModifiedTime;
+
+  // Sanity check. Note that order of attendees is not significant and thus not
+  // guaranteed.
+  const attendees = event.getAttendees();
+  Assert.equal(attendees.length, 3, "there should be three attendees of the event");
+
+  const fooFooson = attendees.find(attendee => attendee.id == "mailto:foo@example.com");
+  Assert.ok(fooFooson, "an attendee should have the address foo@example.com");
+  Assert.equal(fooFooson.commonName, "Foo Fooson", "attendee name should match");
+  Assert.equal(fooFooson.participationStatus, "TENTATIVE", "attendee should be marked tentative");
+  Assert.equal(fooFooson.role, "REQ-PARTICIPANT", "attendee should be required");
+
+  const barBarrington = attendees.find(attendee => attendee.id == "mailto:bar@example.com");
+  Assert.ok(barBarrington, "an attendee should have the address bar@example.com");
+  Assert.equal(barBarrington.commonName, "Bar Barington", "attendee name should match");
+  Assert.equal(barBarrington.participationStatus, "DECLINED", "attendee should have declined");
+  Assert.equal(barBarrington.role, "CHAIR", "attendee should be the meeting chair");
+
+  const bazLuhrmann = attendees.find(attendee => attendee.id == "mailto:baz@example.com");
+  Assert.ok(bazLuhrmann, "an attendee should have the address baz@example.com");
+  Assert.equal(bazLuhrmann.commonName, "Baz Luhrmann", "attendee name should match");
+  Assert.equal(
+    bazLuhrmann.participationStatus,
+    "NEEDS-ACTION",
+    "attendee should not have responded yet"
+  );
+  Assert.equal(bazLuhrmann.role, "OPT-PARTICIPANT", "attendee should be optional");
+  Assert.equal(bazLuhrmann.rsvp, "TRUE", "attendee should be expected to RSVP");
+
+  // Open our event for editing.
+  const { dialogWindow: eventWindow } = await CalendarTestUtils.dayView.editEventAt(window, 1);
+  const attendeesWindow = await openAttendeesWindow(eventWindow);
+
+  // Edit the second attendee to correct their name.
+  findAndEditMatchingRow(
+    attendeesWindow,
+    "Bar Barrington <bar@example.com>",
+    "there should an input containing the provided email",
+    value => value.includes("bar@example.com")
+  );
+
+  // Save and close the event.
+  await closeAttendeesWindow(attendeesWindow);
+  await CalendarTestUtils.items.saveAndCloseItemDialog(eventWindow);
+
+  await TestUtils.waitForCondition(async () => {
+    const item = await calendar.getItem(eventId);
+    return item.lastModifiedTime != eventModified;
+  });
+
+  const editedEvent = await calendar.getItem(eventId);
+  const editedAttendees = editedEvent.getAttendees();
+  Assert.equal(
+    editedAttendees.length,
+    3,
+    "there should be three attendees of the event after editing"
+  );
+
+  // Verify that the first attendee's properties have not been overwritten or
+  // lost.
+  const editedFooFooson = editedAttendees.find(attendee => attendee.id == "mailto:foo@example.com");
+  Assert.ok(editedFooFooson, "an attendee should have the address foo@example.com");
+  Assert.equal(editedFooFooson.commonName, "Foo Fooson", "attendee name should match");
+  Assert.equal(
+    editedFooFooson.participationStatus,
+    "TENTATIVE",
+    "attendee should be marked tentative"
+  );
+  Assert.equal(editedFooFooson.role, "REQ-PARTICIPANT", "attendee should be required");
+
+  // Verify that the second attendee's name has been changed and all other
+  // fields remain untouched.
+  const editedBarBarrington = editedAttendees.find(
+    attendee => attendee.id == "mailto:bar@example.com"
+  );
+  Assert.ok(editedBarBarrington, "an attendee should have the address bar@example.com");
+  Assert.equal(editedBarBarrington.commonName, "Bar Barrington", "attendee name should match");
+  Assert.equal(
+    editedBarBarrington.participationStatus,
+    "DECLINED",
+    "attendee should have declined"
+  );
+  Assert.equal(editedBarBarrington.role, "CHAIR", "attendee should be the meeting chair");
+
+  // Verify that the final attendee's properties remain untouched.
+  const editedBazLuhrmann = editedAttendees.find(
+    attendee => attendee.id == "mailto:baz@example.com"
+  );
+  Assert.ok(editedBazLuhrmann, "an attendee should have the address baz@example.com");
+  Assert.equal(editedBazLuhrmann.commonName, "Baz Luhrmann", "attendee name should match");
+  Assert.equal(
+    editedBazLuhrmann.participationStatus,
+    "NEEDS-ACTION",
+    "attendee should not have responded yet"
+  );
+  Assert.equal(editedBazLuhrmann.role, "OPT-PARTICIPANT", "attendee should be optional");
+  Assert.equal(editedBazLuhrmann.rsvp, "TRUE", "attendee should be expected to RSVP");
+
+  CalendarTestUtils.removeCalendar(calendar);
+});
diff --git a/comm/calendar/test/browser/eventDialog/browser_eventDialog.js b/comm/calendar/test/browser/eventDialog/browser_eventDialog.js
new file mode 100644
index 0000000000..44d75d7169
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_eventDialog.js
@@ -0,0 +1,399 @@
+/* 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 { TIMEOUT_MODAL_DIALOG, checkMonthAlarmIcon, handleDeleteOccurrencePrompt } =
+  ChromeUtils.import("resource://testing-common/calendar/CalendarUtils.jsm");
+var { cancelItemDialog, formatTime, saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+const EVENTTITLE = "Event";
+const EVENTLOCATION = "Location";
+const EVENTDESCRIPTION = "Event Description";
+const EVENTATTENDEE = "foo@example.com";
+const EVENTURL = "https://mozilla.org/";
+const EVENT_ORGANIZER_EMAIL = "pillow@example.com";
+var firstDay;
+
+var { dayView, monthView } = CalendarTestUtils;
+
+let calendar = CalendarTestUtils.createCalendar();
+// This is done so that calItemBase#isInvitation returns true.
+calendar.setProperty("organizerId", `mailto:${EVENT_ORGANIZER_EMAIL}`);
+registerCleanupFunction(() => {
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+add_task(async function testEventDialog() {
+  let now = new Date();
+
+  // Since from other tests we may be elsewhere, make sure we start today.
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(
+    window,
+    now.getUTCFullYear(),
+    now.getUTCMonth() + 1,
+    now.getUTCDate()
+  );
+  await CalendarTestUtils.calendarViewBackward(window, 1);
+
+  // Open month view.
+  await CalendarTestUtils.setCalendarView(window, "month");
+  firstDay = window.currentView().startDay;
+  dump(`First day in view is: ${firstDay.year}-${firstDay.month + 1}-${firstDay.day}\n`);
+
+  // Setup start- & endTime.
+  // Next full hour except last hour of the day.
+  let hour = now.getUTCHours();
+  let startHour = hour == 23 ? hour : (hour + 1) % 24;
+
+  let nextHour = cal.dtz.now();
+  nextHour.resetTo(firstDay.year, firstDay.month, firstDay.day, startHour, 0, 0, cal.dtz.UTC);
+  let startTime = formatTime(nextHour);
+  nextHour.resetTo(
+    firstDay.year,
+    firstDay.month,
+    firstDay.day,
+    (startHour + 1) % 24,
+    0,
+    0,
+    cal.dtz.UTC
+  );
+  let endTime = formatTime(nextHour);
+
+  // Create new event on first day in view.
+  EventUtils.synthesizeMouseAtCenter(monthView.getDayBox(window, 1, 1), {}, window);
+
+  let { dialogWindow, iframeWindow, dialogDocument, iframeDocument } =
+    await CalendarTestUtils.editNewEvent(window);
+
+  // First check all standard-values are set correctly.
+  let startPicker = iframeDocument.getElementById("event-starttime");
+  Assert.equal(startPicker._timepicker._inputField.value, startTime);
+
+  // Check selected calendar.
+  Assert.equal(iframeDocument.getElementById("item-calendar").value, "Test");
+
+  // Check standard title.
+  let defTitle = cal.l10n.getAnyString("calendar", "calendar", "newEvent");
+  Assert.equal(iframeDocument.getElementById("item-title").placeholder, defTitle);
+
+  // Prepare category.
+  let categories = cal.l10n.getAnyString("calendar", "categories", "categories2");
+  // Pick 4th value in a comma-separated list.
+  let category = categories.split(",")[4];
+  // Calculate date to repeat until.
+  let untildate = firstDay.clone();
+  untildate.addDuration(cal.createDuration("P20D"));
+
+  // Fill in the rest of the values.
+  await setData(dialogWindow, iframeWindow, {
+    title: EVENTTITLE,
+    location: EVENTLOCATION,
+    description: EVENTDESCRIPTION,
+    categories: [category],
+    repeat: "daily",
+    repeatuntil: untildate,
+    reminder: "5minutes",
+    privacy: "private",
+    attachment: { add: EVENTURL },
+    attendees: { add: EVENTATTENDEE },
+  });
+
+  // Verify attendee added.
+  EventUtils.synthesizeMouseAtCenter(
+    iframeDocument.getElementById("event-grid-tab-attendees"),
+    {},
+    dialogWindow
+  );
+
+  let attendeesTab = iframeDocument.getElementById("event-grid-tabpanel-attendees");
+  let attendeeNameElements = attendeesTab.querySelectorAll(".attendee-list .attendee-name");
+  Assert.equal(attendeeNameElements.length, 2, "there should be two attendees after save");
+  Assert.equal(attendeeNameElements[0].textContent, EVENT_ORGANIZER_EMAIL);
+  Assert.equal(attendeeNameElements[1].textContent, EVENTATTENDEE);
+  Assert.ok(!iframeDocument.getElementById("notify-attendees-checkbox").checked);
+
+  // Verify private label visible.
+  await TestUtils.waitForCondition(
+    () => !dialogDocument.getElementById("status-privacy-private-box").hasAttribute("collapsed")
+  );
+  dialogDocument.getElementById("event-privacy-menupopup").hidePopup();
+
+  // Add attachment and verify added.
+  EventUtils.synthesizeMouseAtCenter(
+    iframeDocument.getElementById("event-grid-tab-attachments"),
+    {},
+    iframeWindow
+  );
+
+  let attachmentsTab = iframeDocument.getElementById("event-grid-tabpanel-attachments");
+  Assert.equal(attachmentsTab.querySelectorAll("richlistitem").length, 1);
+
+  let alarmPromise = BrowserTestUtils.promiseAlertDialog(
+    undefined,
+    "chrome://calendar/content/calendar-alarm-dialog.xhtml",
+    {
+      callback(alarmWindow) {
+        let dismissAllButton = alarmWindow.document.getElementById("alarm-dismiss-all-button");
+        EventUtils.synthesizeMouseAtCenter(dismissAllButton, {}, alarmWindow);
+      },
+    }
+  );
+
+  // save
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Catch and dismiss alarm.
+  await alarmPromise;
+
+  // Verify event and alarm icon visible until endDate (3 full rows) and check tooltip.
+  for (let row = 1; row <= 3; row++) {
+    for (let col = 1; col <= 7; col++) {
+      await monthView.waitForItemAt(window, row, col, 1);
+      checkMonthAlarmIcon(window, row, col);
+      checkTooltip(row, col, startTime, endTime);
+    }
+  }
+  Assert.ok(!monthView.getItemAt(window, 4, 1, 1));
+
+  // Delete and verify deleted 6th col in row 1.
+  EventUtils.synthesizeMouseAtCenter(monthView.getItemAt(window, 1, 6, 1), {}, window);
+  let elemToDelete = document.getElementById("month-view");
+  await handleDeleteOccurrencePrompt(window, elemToDelete, false);
+
+  await monthView.waitForNoItemAt(window, 1, 6, 1);
+
+  // Verify all others still exist.
+  for (let col = 1; col <= 5; col++) {
+    Assert.ok(monthView.getItemAt(window, 1, col, 1));
+  }
+  Assert.ok(monthView.getItemAt(window, 1, 7, 1));
+
+  for (let row = 2; row <= 3; row++) {
+    for (let col = 1; col <= 7; col++) {
+      Assert.ok(monthView.getItemAt(window, row, col, 1));
+    }
+  }
+
+  // Delete series by deleting last item in row 1 and confirming to delete all.
+  EventUtils.synthesizeMouseAtCenter(monthView.getItemAt(window, 1, 7, 1), {}, window);
+  elemToDelete = document.getElementById("month-view");
+  await handleDeleteOccurrencePrompt(window, elemToDelete, true);
+
+  // Verify all deleted.
+  await monthView.waitForNoItemAt(window, 1, 5, 1);
+  await monthView.waitForNoItemAt(window, 1, 6, 1);
+  await monthView.waitForNoItemAt(window, 1, 7, 1);
+
+  for (let row = 2; row <= 3; row++) {
+    for (let col = 1; col <= 7; col++) {
+      await monthView.waitForNoItemAt(window, row, col, 1);
+    }
+  }
+});
+
+add_task(async function testOpenExistingEventDialog() {
+  let now = new Date();
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(
+    window,
+    now.getUTCFullYear(),
+    now.getUTCMonth() + 1,
+    now.getUTCDate()
+  );
+
+  let createBox = dayView.getHourBoxAt(window, 8);
+
+  // Create a new event.
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, createBox);
+  await setData(dialogWindow, iframeWindow, {
+    title: EVENTTITLE,
+    location: EVENTLOCATION,
+    description: EVENTDESCRIPTION,
+  });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  let eventBox = await dayView.waitForEventBoxAt(window, 1);
+
+  // Open the event in the summary dialog, it will fail if otherwise.
+  let eventWin = await CalendarTestUtils.viewItem(window, eventBox);
+  Assert.equal(
+    eventWin.document.querySelector("calendar-item-summary .item-title").textContent,
+    EVENTTITLE
+  );
+  Assert.equal(
+    eventWin.document.querySelector("calendar-item-summary .item-location").textContent,
+    EVENTLOCATION
+  );
+  Assert.equal(
+    eventWin.document.querySelector("calendar-item-summary .item-description").contentDocument.body
+      .innerText,
+    EVENTDESCRIPTION
+  );
+  EventUtils.synthesizeKey("VK_ESCAPE", {}, eventWin);
+
+  eventBox.focus();
+  EventUtils.synthesizeKey("VK_DELETE", {}, window);
+  await dayView.waitForNoEventBoxAt(window, 1);
+});
+
+add_task(async function testEventReminderDisplay() {
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2020, 1, 1);
+
+  let createBox = dayView.getHourBoxAt(window, 8);
+
+  // Create an event without a reminder.
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, createBox);
+  await setData(dialogWindow, iframeWindow, {
+    title: EVENTTITLE,
+    location: EVENTLOCATION,
+    description: EVENTDESCRIPTION,
+  });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  let eventBox = await dayView.waitForEventBoxAt(window, 1);
+
+  let eventWindow = await CalendarTestUtils.viewItem(window, eventBox);
+  let doc = eventWindow.document;
+  let row = doc.querySelector(".reminder-row");
+  Assert.ok(row.hidden, "reminder dropdown is not displayed");
+  EventUtils.synthesizeKey("VK_ESCAPE", {}, eventWindow);
+
+  await CalendarTestUtils.goToDate(window, 2020, 2, 1);
+  createBox = dayView.getHourBoxAt(window, 8);
+
+  // Create an event with a reminder.
+  ({ dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, createBox));
+  await setData(dialogWindow, iframeWindow, {
+    title: EVENTTITLE,
+    location: EVENTLOCATION,
+    description: EVENTDESCRIPTION,
+    reminder: "1week",
+  });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  eventBox = await dayView.waitForEventBoxAt(window, 1);
+  eventWindow = await CalendarTestUtils.viewItem(window, eventBox);
+  doc = eventWindow.document;
+  row = doc.querySelector(".reminder-row");
+
+  Assert.ok(
+    row.textContent.includes("7 days before"),
+    "the details are shown when a reminder is set"
+  );
+  EventUtils.synthesizeKey("VK_ESCAPE", {}, eventWindow);
+
+  // Create an invitation.
+  let icalString =
+    "BEGIN:VCALENDAR\r\n" +
+    "PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN\r\n" +
+    "VERSION:2.0\r\n" +
+    "BEGIN:VEVENT\r\n" +
+    "CREATED:20200301T152601Z\r\n" +
+    "DTSTAMP:20200301T192729Z\r\n" +
+    "UID:x137e\r\n" +
+    "SUMMARY:Nap Time\r\n" +
+    "ORGANIZER;CN=Papa Bois:mailto:papabois@example.com\r\n" +
+    "ATTENDEE;RSVP=TRUE;CN=pillow@example.com;PARTSTAT=NEEDS-ACTION;CUTY\r\n" +
+    " PE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;X-NUM-GUESTS=0:mailto:pillow@example.com\r\n" +
+    "DTSTART:20200301T153000Z\r\n" +
+    "DTEND:20200301T163000Z\r\n" +
+    "DESCRIPTION:Slumber In Lumber\r\n" +
+    "SEQUENCE:0\r\n" +
+    "TRANSP:OPAQUE\r\n" +
+    "BEGIN:VALARM\r\n" +
+    "TRIGGER:-PT30M\r\n" +
+    "REPEAT:2\r\n" +
+    "DURATION:PT15M\r\n" +
+    "ACTION:DISPLAY\r\n" +
+    "END:VALARM\r\n" +
+    "END:VEVENT\r\n" +
+    "END:VCALENDAR\r\n";
+
+  let calendarEvent = await calendar.addItem(new CalEvent(icalString));
+  await CalendarTestUtils.goToDate(window, 2020, 3, 1);
+  eventBox = await dayView.waitForEventBoxAt(window, 1);
+
+  eventWindow = await CalendarTestUtils.viewItem(window, eventBox);
+  doc = eventWindow.document;
+  row = doc.querySelector(".reminder-row");
+
+  Assert.ok(!row.hidden, "reminder row is displayed");
+  Assert.ok(row.querySelector("menulist") != null, "reminder dropdown is available");
+  EventUtils.synthesizeKey("VK_ESCAPE", {}, eventWindow);
+
+  // Delete directly, as using the UI causes a prompt to appear.
+  calendar.deleteItem(calendarEvent);
+  await dayView.waitForNoEventBoxAt(window, 1);
+});
+
+/**
+ * Test that using CTRL+Enter does not result in two events being created.
+ * This only happens in the dialog window. See bug 1668478.
+ */
+add_task(async function testCtrlEnterShortcut() {
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2020, 9, 1);
+
+  let createBox = dayView.getHourBoxAt(window, 8);
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, createBox);
+  await setData(dialogWindow, iframeWindow, {
+    title: EVENTTITLE,
+    location: EVENTLOCATION,
+    description: EVENTDESCRIPTION,
+  });
+  EventUtils.synthesizeKey("VK_RETURN", { ctrlKey: true }, dialogWindow);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+
+  // Give the event boxes enough time to appear before checking for duplicates.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  let events = document.querySelectorAll("calendar-month-day-box-item");
+  Assert.equal(events.length, 1, "event was created once");
+
+  if (Services.focus.activeWindow != window) {
+    await BrowserTestUtils.waitForEvent(window, "focus");
+  }
+
+  events[0].focus();
+  EventUtils.synthesizeKey("VK_DELETE", {}, window);
+});
+
+function checkTooltip(row, col, startTime, endTime) {
+  let item = monthView.getItemAt(window, row, col, 1);
+
+  let toolTipNode = document.getElementById("itemTooltip");
+  toolTipNode.ownerGlobal.onMouseOverItem({ currentTarget: item });
+
+  function getDescription(index) {
+    return toolTipNode.querySelector(
+      `.tooltipHeaderTable > tr:nth-of-type(${index}) > .tooltipHeaderDescription`
+    ).textContent;
+  }
+
+  // Check title.
+  Assert.equal(getDescription(1), EVENTTITLE);
+
+  // Check date and time.
+  let dateTime = getDescription(3);
+
+  let currDate = firstDay.clone();
+  currDate.addDuration(cal.createDuration(`P${7 * (row - 1) + (col - 1)}D`));
+  let startDate = cal.dtz.formatter.formatDate(currDate);
+
+  Assert.ok(dateTime.includes(`${startDate} ${startTime} – `));
+
+  // This could be on the next day if it is 00:00.
+  Assert.ok(dateTime.endsWith(endTime));
+}
diff --git a/comm/calendar/test/browser/eventDialog/browser_eventDialogDescriptionEditor.js b/comm/calendar/test/browser/eventDialog/browser_eventDialogDescriptionEditor.js
new file mode 100644
index 0000000000..d838330e73
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_eventDialogDescriptionEditor.js
@@ -0,0 +1,154 @@
+/* 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 { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+const { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+add_setup(async function () {
+  await CalendarTestUtils.setCalendarView(window, "day");
+  CalendarTestUtils.goToDate(window, 2023, 2, 18);
+});
+
+add_task(async function testPastePreformattedWithLinebreak() {
+  const calendar = CalendarTestUtils.createCalendar();
+
+  // Create an event which currently has no description.
+  const event = await calendar.addItem(
+    new CalEvent(CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      SUMMARY:An event
+      DTSTART:20230218T100000Z
+      DTEND:20230218T110000Z
+      END:VEVENT
+    `)
+  );
+
+  // Remember event details so we can refetch it after editing.
+  const eventId = event.id;
+  const eventModified = event.lastModifiedTime;
+
+  // Sanity check.
+  Assert.equal(event.descriptionHTML, null, "event should not have an HTML description");
+  Assert.equal(event.descriptionText, null, "event should not have a text description");
+
+  // Open our event for editing.
+  const { dialogWindow: eventWindow, iframeDocument } = await CalendarTestUtils.dayView.editEventAt(
+    window,
+    1
+  );
+
+  const editor = iframeDocument.getElementById("item-description");
+  editor.focus();
+
+  const expectedHTML =
+    "<pre><code>This event is one which includes\nan explicit linebreak inside a pre tag.</code></pre>";
+
+  // Create a paste which includes HTML data, which the editor will recognize as
+  // HTML and paste with formatting by default.
+  const stringData = Cc["@mozilla.org/supports-string;1"].createInstance(Ci.nsISupportsString);
+  stringData.data = expectedHTML;
+
+  const transferable = Cc["@mozilla.org/widget/transferable;1"].createInstance(Ci.nsITransferable);
+  transferable.init(null);
+  transferable.addDataFlavor("text/html");
+  transferable.setTransferData("text/html", stringData);
+  Services.clipboard.setData(transferable, null, Ci.nsIClipboard.kGlobalClipboard);
+
+  // Paste.
+  EventUtils.synthesizeKey("v", { accelKey: true }, eventWindow);
+
+  await CalendarTestUtils.items.saveAndCloseItemDialog(eventWindow);
+
+  await TestUtils.waitForCondition(async () => {
+    const item = await calendar.getItem(eventId);
+    return item.lastModifiedTime != eventModified;
+  });
+
+  const editedEvent = await calendar.getItem(eventId);
+
+  // Verify that the description has been set appropriately. There should be no
+  // change to the HTML, which is preformatted, and the text description should
+  // include a linebreak in the same place as the HTML.
+  Assert.equal(editedEvent.descriptionHTML, expectedHTML, "HTML description should match input");
+  Assert.equal(
+    editedEvent.descriptionText,
+    "This event is one which includes\nan explicit linebreak inside a pre tag.",
+    "text description should include linebreak"
+  );
+
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+add_task(async function testTypeLongTextWithLinebreaks() {
+  const calendar = CalendarTestUtils.createCalendar();
+
+  // Create an event which currently has no description.
+  const event = await calendar.addItem(
+    new CalEvent(CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      SUMMARY:An event
+      DTSTART:20230218T100000Z
+      DTEND:20230218T110000Z
+      END:VEVENT
+    `)
+  );
+
+  // Remember event details so we can refetch it after editing.
+  const eventId = event.id;
+  const eventModified = event.lastModifiedTime;
+
+  // Sanity check.
+  Assert.equal(event.descriptionHTML, null, "event should not have an HTML description");
+  Assert.equal(event.descriptionText, null, "event should not have a text description");
+
+  // Open our event for editing.
+  const {
+    dialogWindow: eventWindow,
+    iframeDocument,
+    iframeWindow,
+  } = await CalendarTestUtils.dayView.editEventAt(window, 1);
+
+  const editor = iframeDocument.getElementById("item-description");
+  editor.focus();
+
+  // Insert text with several long lines and explicit linebreaks.
+  const firstLine =
+    "This event is pretty much just plain text, albeit it has some pretty long lines so that we can ensure that we don't accidentally wrap it during conversion.";
+  EventUtils.sendString(firstLine, iframeWindow);
+  EventUtils.sendKey("RETURN", iframeWindow);
+
+  const secondLine = "This line follows immediately after a linebreak.";
+  EventUtils.sendString(secondLine, iframeWindow);
+  EventUtils.sendKey("RETURN", iframeWindow);
+  EventUtils.sendKey("RETURN", iframeWindow);
+
+  const thirdLine =
+    "And one after a couple more linebreaks, for good measure. It might as well be a fairly long string as well, just so we're certain.";
+  EventUtils.sendString(thirdLine, iframeWindow);
+
+  await CalendarTestUtils.items.saveAndCloseItemDialog(eventWindow);
+
+  await TestUtils.waitForCondition(async () => {
+    const item = await calendar.getItem(eventId);
+    return item.lastModifiedTime != eventModified;
+  });
+
+  const editedEvent = await calendar.getItem(eventId);
+
+  // Verify that the description has been set appropriately. The HTML should
+  // match the input and use <br> as a linebreak, while the text should not be
+  // wrapped and should use \n as a linebreak.
+  Assert.equal(
+    editedEvent.descriptionHTML,
+    `${firstLine}<br>${secondLine}<br><br>${thirdLine}`,
+    "HTML description should match input with <br> for linebreaks"
+  );
+  Assert.equal(
+    editedEvent.descriptionText,
+    `${firstLine}\n${secondLine}\n\n${thirdLine}`,
+    "text description should match input with linebreaks"
+  );
+
+  CalendarTestUtils.removeCalendar(calendar);
+});
diff --git a/comm/calendar/test/browser/eventDialog/browser_eventDialogEditButton.js b/comm/calendar/test/browser/eventDialog/browser_eventDialogEditButton.js
new file mode 100644
index 0000000000..b7730444b2
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_eventDialogEditButton.js
@@ -0,0 +1,223 @@
+/* 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/. */
+
+/**
+ * Tests for the edit button displayed in the calendar summary dialog.
+ */
+
+const { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalRecurrenceInfo: "resource:///modules/CalRecurrenceInfo.jsm",
+});
+
+const calendar = CalendarTestUtils.createCalendar("Edit Button Test", "storage");
+
+registerCleanupFunction(() => {
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+function createNonRecurringEvent() {
+  let event = new CalEvent();
+  event.title = "Non-Recurring Event";
+  event.startDate = cal.createDateTime("20191201T000001Z");
+  return event;
+}
+
+function createRecurringEvent() {
+  let event = new CalEvent();
+  event.title = "Recurring Event";
+  event.startDate = cal.createDateTime("20200101T000001Z");
+  event.recurrenceInfo = new CalRecurrenceInfo(event);
+  event.recurrenceInfo.appendRecurrenceItem(cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=30"));
+  return event;
+}
+
+/**
+ * Test the correct edit button is shown for a non-recurring event.
+ */
+add_task(async function testNonRecurringEvent() {
+  let event = await calendar.addItem(createNonRecurringEvent());
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(event.startDate);
+
+  let eventWindow = await CalendarTestUtils.monthView.viewItemAt(window, 1, 1, 1);
+  let editMenuButton = eventWindow.document.querySelector(
+    "#calendar-summary-dialog-edit-menu-button"
+  );
+
+  Assert.ok(
+    !BrowserTestUtils.is_visible(editMenuButton),
+    "edit dropdown is not visible for non-recurring event"
+  );
+
+  let editButton = eventWindow.document.querySelector("#calendar-summary-dialog-edit-button");
+
+  Assert.ok(
+    BrowserTestUtils.is_visible(editButton),
+    "edit button is visible for non-recurring event"
+  );
+  await CalendarTestUtils.items.cancelItemDialog(eventWindow);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Test the edit button for a non-recurring event actual edits the event.
+ */
+add_task(async function testEditNonRecurringEvent() {
+  let event = await calendar.addItem(createNonRecurringEvent());
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(event.startDate);
+
+  let modificationPromise = new Promise(resolve => {
+    calendar.wrappedJSObject.addObserver({
+      QueryInterface: ChromeUtils.generateQI(["calIObserver"]),
+      onModifyItem(aNewItem, aOldItem) {
+        calendar.wrappedJSObject.removeObserver(this);
+        resolve();
+      },
+    });
+  });
+
+  let { dialogWindow, iframeDocument } = await CalendarTestUtils.monthView.editItemAt(
+    window,
+    1,
+    1,
+    1
+  );
+
+  let newTitle = "Edited Non-Recurring Event";
+  iframeDocument.querySelector("#item-title").value = newTitle;
+
+  await CalendarTestUtils.items.saveAndCloseItemDialog(dialogWindow);
+  await modificationPromise;
+
+  let viewWindow = await CalendarTestUtils.monthView.viewItemAt(window, 1, 1, 1);
+  let actualTitle = viewWindow.document.querySelector(
+    "#calendar-item-summary .item-title"
+  ).textContent;
+
+  Assert.equal(actualTitle, newTitle, "edit non-recurring event successful");
+  await CalendarTestUtils.items.cancelItemDialog(viewWindow);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Tests the dropdown menu is displayed for a recurring event.
+ */
+add_task(async function testRecurringEvent() {
+  let event = await calendar.addItem(createRecurringEvent());
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(event.startDate);
+
+  let viewWindow = await CalendarTestUtils.monthView.viewItemAt(window, 1, 6, 1);
+
+  Assert.ok(
+    !BrowserTestUtils.is_visible(
+      viewWindow.document.querySelector("#calendar-summary-dialog-edit-button")
+    ),
+    "non-recurring edit button is not visible for recurring event"
+  );
+  Assert.ok(
+    BrowserTestUtils.is_visible(
+      viewWindow.document.querySelector("#calendar-summary-dialog-edit-menu-button")
+    ),
+    "edit dropdown is visible for recurring event"
+  );
+
+  await CalendarTestUtils.items.cancelItemDialog(viewWindow);
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Tests the dropdown menu allows a single occurrence of a repeating event
+ * to be edited.
+ */
+add_task(async function testEditThisOccurrence() {
+  let event = createRecurringEvent();
+  event = await calendar.addItem(event);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(event.startDate);
+
+  let modificationPromise = new Promise(resolve => {
+    calendar.wrappedJSObject.addObserver({
+      QueryInterface: ChromeUtils.generateQI(["calIObserver"]),
+      onModifyItem(aNewItem, aOldItem) {
+        calendar.wrappedJSObject.removeObserver(this);
+        resolve();
+      },
+    });
+  });
+
+  let { dialogWindow, iframeDocument } = await CalendarTestUtils.monthView.editItemOccurrenceAt(
+    window,
+    1,
+    6,
+    1
+  );
+
+  let originalTitle = event.title;
+  let newTitle = "Edited This Occurrence";
+
+  iframeDocument.querySelector("#item-title").value = newTitle;
+  await CalendarTestUtils.items.saveAndCloseItemDialog(dialogWindow);
+
+  await modificationPromise;
+
+  let changedBox = await CalendarTestUtils.monthView.waitForItemAt(window, 1, 6, 1);
+  let eventBoxes = document.querySelectorAll("calendar-month-day-box-item");
+
+  for (let box of eventBoxes) {
+    if (box !== changedBox) {
+      Assert.equal(
+        box.item.title,
+        originalTitle,
+        '"Edit this occurrence" did not edit other occurrences'
+      );
+    } else {
+      Assert.equal(box.item.title, newTitle, '"Edit this occurrence only" edited this occurrence.');
+    }
+  }
+  await calendar.deleteItem(event);
+});
+
+/**
+ * Tests the dropdown menu allows all occurrences of a recurring event to be
+ * edited.
+ */
+add_task(async function testEditAllOccurrences() {
+  let event = await calendar.addItem(createRecurringEvent());
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(event.startDate);
+
+  // Setup an observer so we can wait for the event boxes to be updated.
+  let boxesRefreshed = false;
+  let observer = new MutationObserver(() => (boxesRefreshed = true));
+  observer.observe(document.querySelector("#month-view"), {
+    childList: true,
+    subtree: true,
+  });
+
+  let { dialogWindow, iframeDocument } = await CalendarTestUtils.monthView.editItemOccurrencesAt(
+    window,
+    1,
+    6,
+    1
+  );
+
+  let newTitle = "Edited All Occurrences";
+
+  iframeDocument.querySelector("#item-title").value = newTitle;
+  await CalendarTestUtils.items.saveAndCloseItemDialog(dialogWindow);
+  await TestUtils.waitForCondition(() => boxesRefreshed, "event boxes did not refresh in time");
+
+  let eventBoxes = document.querySelectorAll("calendar-month-day-box-item");
+  for (let box of eventBoxes) {
+    Assert.equal(box.item.title, newTitle, '"Edit all occurrences" edited each occurrence');
+  }
+  await calendar.deleteItem(event);
+});
diff --git a/comm/calendar/test/browser/eventDialog/browser_eventDialogModificationPrompt.js b/comm/calendar/test/browser/eventDialog/browser_eventDialogModificationPrompt.js
new file mode 100644
index 0000000000..b0f3282b24
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_eventDialogModificationPrompt.js
@@ -0,0 +1,160 @@
+/* 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/. */
+
+requestLongerTimeout(2);
+
+var { cancelItemDialog, saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+var { data, newlines } = setupData();
+
+var { dayView } = CalendarTestUtils;
+
+let calendar = CalendarTestUtils.createCalendar();
+// This is done so that calItemBase#isInvitation returns true.
+calendar.setProperty("organizerId", "mailto:pillow@example.com");
+registerCleanupFunction(() => {
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+// Test that closing an event dialog with no changes does not prompt for save.
+add_task(async function testEventDialogModificationPrompt() {
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  let createbox = dayView.getHourBoxAt(window, 8);
+
+  // Create new event.
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, createbox);
+  let categories = cal.l10n.getAnyString("calendar", "categories", "categories2").split(",");
+  data[0].categories.push(categories[0]);
+  data[1].categories.push(categories[1], categories[2]);
+
+  // Enter first set of data.
+  await setData(dialogWindow, iframeWindow, data[0]);
+  await saveAndCloseItemDialog(dialogWindow);
+
+  let eventbox = await dayView.waitForEventBoxAt(window, 1);
+
+  // Open, but change nothing.
+  ({ dialogWindow, iframeWindow } = await CalendarTestUtils.editItem(window, eventbox));
+  // Escape the event window, there should be no prompt to save event.
+  cancelItemDialog(dialogWindow);
+  // Wait to see if the prompt appears.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  eventbox = await dayView.waitForEventBoxAt(window, 1);
+  // Open, change all values then revert the changes.
+  ({ dialogWindow, iframeWindow } = await CalendarTestUtils.editItem(window, eventbox));
+  // Change all values.
+  await setData(dialogWindow, iframeWindow, data[1]);
+
+  // Edit all values back to original.
+  await setData(dialogWindow, iframeWindow, data[0]);
+
+  // Escape the event window, there should be no prompt to save event.
+  cancelItemDialog(dialogWindow);
+  // Wait to see if the prompt appears.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  // Delete event.
+  document.getElementById("day-view").focus();
+  if (window.currentView().getSelectedItems().length == 0) {
+    EventUtils.synthesizeMouseAtCenter(eventbox, {}, window);
+  }
+  Assert.equal(eventbox.isEditing, false, "event is not being edited");
+  EventUtils.synthesizeKey("VK_DELETE", {}, window);
+  await dayView.waitForNoEventBoxAt(window, 1);
+});
+
+add_task(async function testDescriptionWhitespace() {
+  for (let i = 0; i < newlines.length; i++) {
+    // test set i
+    let createbox = dayView.getHourBoxAt(window, 8);
+    let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, createbox);
+    await setData(dialogWindow, iframeWindow, newlines[i]);
+    await saveAndCloseItemDialog(dialogWindow);
+
+    let eventbox = await dayView.waitForEventBoxAt(window, 1);
+
+    // Open and close.
+    ({ dialogWindow, iframeWindow } = await CalendarTestUtils.editItem(window, eventbox));
+    await setData(dialogWindow, iframeWindow, newlines[i]);
+    cancelItemDialog(dialogWindow);
+    // Wait to see if the prompt appears.
+    // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    // Delete it.
+    document.getElementById("day-view").focus();
+    if (window.currentView().getSelectedItems().length == 0) {
+      EventUtils.synthesizeMouseAtCenter(eventbox, {}, window);
+    }
+    Assert.equal(eventbox.isEditing, false, "event is not being edited");
+    EventUtils.synthesizeKey("VK_DELETE", {}, window);
+    await dayView.waitForNoEventBoxAt(window, 1);
+  }
+});
+
+function setupData() {
+  let date1 = cal.createDateTime("20090101T080000Z");
+  let date2 = cal.createDateTime("20090102T090000Z");
+  let date3 = cal.createDateTime("20090103T100000Z");
+  return {
+    data: [
+      {
+        title: "title1",
+        location: "location1",
+        description: "description1",
+        categories: [],
+        allday: false,
+        startdate: date1,
+        starttime: date1,
+        enddate: date2,
+        endtime: date2,
+        repeat: "none",
+        reminder: "none",
+        priority: "normal",
+        privacy: "public",
+        status: "confirmed",
+        freebusy: "busy",
+        timezonedisplay: true,
+        attachment: { add: "https://mozilla.org" },
+        attendees: { add: "foo@bar.de,foo@bar.com" },
+      },
+      {
+        title: "title2",
+        location: "location2",
+        description: "description2",
+        categories: [],
+        allday: true,
+        startdate: date2,
+        starttime: date2,
+        enddate: date3,
+        endtime: date3,
+        repeat: "daily",
+        reminder: "5minutes",
+        priority: "high",
+        privacy: "private",
+        status: "tentative",
+        freebusy: "free",
+        timezonedisplay: false,
+        attachment: { remove: "mozilla.org" },
+        attendees: { remove: "foo@bar.de,foo@bar.com" },
+      },
+    ],
+    newlines: [
+      { title: "title", description: "  test spaces  " },
+      { title: "title", description: "\ntest newline\n" },
+      { title: "title", description: "\rtest \\r\r" },
+      { title: "title", description: "\r\ntest \\r\\n\r\n" },
+      { title: "title", description: "\ttest \\t\t" },
+    ],
+  };
+}
diff --git a/comm/calendar/test/browser/eventDialog/browser_utf8.js b/comm/calendar/test/browser/eventDialog/browser_utf8.js
new file mode 100644
index 0000000000..5e9ff82d19
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/browser_utf8.js
@@ -0,0 +1,56 @@
+/* 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 { cancelItemDialog, saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var UTF8STRING = " 💣 💥  ☣  ";
+
+add_task(async function testUTF8() {
+  let calendar = CalendarTestUtils.createCalendar();
+  Services.prefs.setStringPref("calendar.categories.names", UTF8STRING);
+
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+    Services.prefs.clearUserPref("calendar.categories.names");
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+
+  // Create new event.
+  let eventBox = CalendarTestUtils.dayView.getHourBoxAt(window, 8);
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, eventBox);
+  // Fill in name, location, description.
+  await setData(dialogWindow, iframeWindow, {
+    title: UTF8STRING,
+    location: UTF8STRING,
+    description: UTF8STRING,
+    categories: [UTF8STRING],
+  });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // open
+  let { dialogWindow: dlgWindow, iframeDocument } = await CalendarTestUtils.dayView.editEventAt(
+    window,
+    1
+  );
+  // Check values.
+  Assert.equal(iframeDocument.getElementById("item-title").value, UTF8STRING);
+  Assert.equal(iframeDocument.getElementById("item-location").value, UTF8STRING);
+  // The trailing spaces confuse innerText, so we'll do this longhand
+  let editorEl = iframeDocument.getElementById("item-description");
+  let editor = editorEl.getEditor(editorEl.contentWindow);
+  let description = editor.outputToString("text/plain", 0);
+  // The HTML editor makes the first character a NBSP instead of a space.
+  Assert.equal(description.replaceAll("\xA0", " "), UTF8STRING);
+  Assert.ok(
+    iframeDocument
+      .getElementById("item-categories")
+      .querySelector(`menuitem[label="${UTF8STRING}"][checked]`)
+  );
+
+  // Escape the event window.
+  cancelItemDialog(dlgWindow);
+});
diff --git a/comm/calendar/test/browser/eventDialog/data/guests.txt b/comm/calendar/test/browser/eventDialog/data/guests.txt
new file mode 100644
index 0000000000..e2959cf71e
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/data/guests.txt
@@ -0,0 +1,2 @@
+Nobody
+No one
diff --git a/comm/calendar/test/browser/eventDialog/head.js b/comm/calendar/test/browser/eventDialog/head.js
new file mode 100644
index 0000000000..0646cd709c
--- /dev/null
+++ b/comm/calendar/test/browser/eventDialog/head.js
@@ -0,0 +1,97 @@
+/* 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 { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+// If the "do you want to save the event?" prompt appears, the test failed.
+// Listen for all windows opening, and if one is the save prompt, fail.
+var savePromptObserver = {
+  async observe(win, topic) {
+    if (topic == "domwindowopened") {
+      await BrowserTestUtils.waitForEvent(win, "load");
+      // Make sure this is a prompt window.
+      if (win.location.href == "chrome://global/content/commonDialog.xhtml") {
+        let doc = win.document;
+        // Adding attachments also shows a prompt, but we can tell which one
+        // this is by checking whether the textbox is visible.
+        if (doc.querySelector("#loginContainer").hasAttribute("hidden")) {
+          Assert.report(true, undefined, undefined, "Unexpected save prompt appeared");
+          doc.querySelector("dialog").getButton("cancel").click();
+        }
+      }
+    }
+  },
+};
+Services.ww.registerNotification(savePromptObserver);
+
+const calendarViewsInitialState = CalendarTestUtils.saveCalendarViewsState(window);
+
+registerCleanupFunction(async () => {
+  Services.ww.unregisterNotification(savePromptObserver);
+  await CalendarTestUtils.restoreCalendarViewsState(window, calendarViewsInitialState);
+});
+
+function openAttendeesWindow(eventWindowOrArgs) {
+  let attendeesWindowPromise = BrowserTestUtils.promiseAlertDialogOpen(
+    null,
+    "chrome://calendar/content/calendar-event-dialog-attendees.xhtml",
+    {
+      async callback(win) {
+        await new Promise(resolve => win.setTimeout(resolve));
+      },
+    }
+  );
+
+  if (Window.isInstance(eventWindowOrArgs)) {
+    EventUtils.synthesizeMouseAtCenter(
+      eventWindowOrArgs.document.getElementById("button-attendees"),
+      {},
+      eventWindowOrArgs
+    );
+  } else {
+    openDialog(
+      "chrome://calendar/content/calendar-event-dialog-attendees.xhtml",
+      "_blank",
+      "chrome,titlebar,resizable",
+      eventWindowOrArgs
+    );
+  }
+  return attendeesWindowPromise;
+}
+
+async function closeAttendeesWindow(attendeesWindow, buttonAction = "accept") {
+  let closedPromise = BrowserTestUtils.domWindowClosed(attendeesWindow);
+  let dialog = attendeesWindow.document.querySelector("dialog");
+  dialog.getButton(buttonAction).click();
+  await closedPromise;
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+function findAndFocusMatchingRow(attendeesWindow, message, matchFunction) {
+  // Get the attendee row for which the input matches.
+  const attendeeList = attendeesWindow.document.getElementById("attendee-list");
+  const attendeeInput = Array.from(attendeeList.children)
+    .map(child => child.querySelector("input"))
+    .find(input => {
+      return input ? matchFunction(input.value) : false;
+    });
+  Assert.ok(attendeeInput, message);
+
+  attendeeInput.focus();
+
+  return attendeeInput;
+}
+
+function findAndEditMatchingRow(attendeesWindow, newValue, message, matchFunction) {
+  // Get the attendee row we wish to edit.
+  const attendeeInput = findAndFocusMatchingRow(attendeesWindow, message, matchFunction);
+
+  // Set the new value of the row. We set the input value directly due to issues
+  // experienced trying to use simulated keystrokes.
+  attendeeInput.value = newValue;
+  EventUtils.synthesizeKey("VK_RETURN", {}, attendeesWindow);
+}
diff --git a/comm/calendar/test/browser/head.js b/comm/calendar/test/browser/head.js
new file mode 100644
index 0000000000..f76cc85754
--- /dev/null
+++ b/comm/calendar/test/browser/head.js
@@ -0,0 +1,374 @@
+/* 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/calendar-views-utils.js */
+
+/* globals openOptionsDialog, openAddonsMgr */
+
+const { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+async function openTasksTab() {
+  let tabmail = document.getElementById("tabmail");
+  let tasksMode = tabmail.tabModes.tasks;
+
+  if (tasksMode.tabs.length == 1) {
+    tabmail.selectedTab = tasksMode.tabs[0];
+  } else {
+    let tasksTabButton = document.getElementById("tasksButton");
+    EventUtils.synthesizeMouseAtCenter(tasksTabButton, { clickCount: 1 });
+  }
+
+  is(tasksMode.tabs.length, 1, "tasks tab is open");
+  is(tabmail.selectedTab, tasksMode.tabs[0], "tasks tab is selected");
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+async function closeTasksTab() {
+  let tabmail = document.getElementById("tabmail");
+  let tasksMode = tabmail.tabModes.tasks;
+
+  if (tasksMode.tabs.length == 1) {
+    tabmail.closeTab(tasksMode.tabs[0]);
+  }
+
+  is(tasksMode.tabs.length, 0, "tasks tab is not open");
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+/**
+ * Currently there's always a folder tab open, hence "select" not "open".
+ */
+async function selectFolderTab() {
+  const tabmail = document.getElementById("tabmail");
+  const folderMode = tabmail.tabModes.mail3PaneTab;
+
+  tabmail.selectedTab = folderMode.tabs[0];
+
+  is(folderMode.tabs.length > 0, true, "at least one folder tab is open");
+  is(tabmail.selectedTab, folderMode.tabs[0], "a folder tab is selected");
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+async function openChatTab() {
+  let tabmail = document.getElementById("tabmail");
+  let chatMode = tabmail.tabModes.chat;
+
+  if (chatMode.tabs.length == 1) {
+    tabmail.selectedTab = chatMode.tabs[0];
+  } else {
+    window.showChatTab();
+  }
+
+  is(chatMode.tabs.length, 1, "chat tab is open");
+  is(tabmail.selectedTab, chatMode.tabs[0], "chat tab is selected");
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+async function closeChatTab() {
+  let tabmail = document.getElementById("tabmail");
+  let chatMode = tabmail.tabModes.chat;
+
+  if (chatMode.tabs.length == 1) {
+    tabmail.closeTab(chatMode.tabs[0]);
+  }
+
+  is(chatMode.tabs.length, 0, "chat tab is not open");
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+/**
+ * Opens a new calendar event or task tab.
+ *
+ * @param {string} tabMode - Mode of the new tab, either `calendarEvent` or `calendarTask`.
+ * @returns {string} - The id of the new tab's panel element.
+ */
+async function _openNewCalendarItemTab(tabMode) {
+  let tabmail = document.getElementById("tabmail");
+  let itemTabs = tabmail.tabModes[tabMode].tabs;
+  let previousTabCount = itemTabs.length;
+
+  Services.prefs.setBoolPref("calendar.item.editInTab", true);
+  let buttonId = "sidePanelNewEvent";
+  if (tabMode == "calendarTask") {
+    await openTasksTab();
+    buttonId = "sidePanelNewTask";
+  } else {
+    await CalendarTestUtils.openCalendarTab(window);
+  }
+
+  let newItemButton = document.getElementById(buttonId);
+  EventUtils.synthesizeMouseAtCenter(newItemButton, { clickCount: 1 });
+
+  let newTab = itemTabs[itemTabs.length - 1];
+
+  is(itemTabs.length, previousTabCount + 1, `new ${tabMode} tab is open`);
+  is(tabmail.selectedTab, newTab, `new ${tabMode} tab is selected`);
+
+  await BrowserTestUtils.browserLoaded(newTab.iframe);
+  await new Promise(resolve => setTimeout(resolve));
+  return newTab.panel.id;
+}
+
+let openNewCalendarEventTab = _openNewCalendarItemTab.bind(null, "calendarEvent");
+let openNewCalendarTaskTab = _openNewCalendarItemTab.bind(null, "calendarTask");
+
+/**
+ * Selects an existing (open) calendar event or task tab.
+ *
+ * @param {string} tabMode - The tab mode, either `calendarEvent` or `calendarTask`.
+ * @param {string} panelId - The id of the tab's panel element.
+ */
+async function _selectCalendarItemTab(tabMode, panelId) {
+  let tabmail = document.getElementById("tabmail");
+  let itemTabs = tabmail.tabModes[tabMode].tabs;
+  let tabToSelect = itemTabs.find(tab => tab.panel.id == panelId);
+
+  ok(tabToSelect, `${tabMode} tab is open`);
+
+  tabmail.selectedTab = tabToSelect;
+
+  is(tabmail.selectedTab, tabToSelect, `${tabMode} tab is selected`);
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+let selectCalendarEventTab = _selectCalendarItemTab.bind(null, "calendarEvent");
+let selectCalendarTaskTab = _selectCalendarItemTab.bind(null, "calendarTask");
+
+/**
+ * Closes a calendar event or task tab.
+ *
+ * @param {string} tabMode - The tab mode, either `calendarEvent` or `calendarTask`.
+ * @param {string} panelId - The id of the panel of the tab to close.
+ */
+async function _closeCalendarItemTab(tabMode, panelId) {
+  let tabmail = document.getElementById("tabmail");
+  let itemTabs = tabmail.tabModes[tabMode].tabs;
+  let previousTabCount = itemTabs.length;
+  let itemTab = itemTabs.find(tab => tab.panel.id == panelId);
+
+  if (itemTab) {
+    // Tab does not immediately close, so wait for it.
+    let tabClosedPromise = new Promise(resolve => {
+      itemTab.tabNode.addEventListener("TabClose", resolve, { once: true });
+    });
+    tabmail.closeTab(itemTab);
+    await tabClosedPromise;
+  }
+
+  is(itemTabs.length, previousTabCount - 1, `${tabMode} tab was closed`);
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+let closeCalendarEventTab = _closeCalendarItemTab.bind(null, "calendarEvent");
+let closeCalendarTaskTab = _closeCalendarItemTab.bind(null, "calendarTask");
+
+async function openPreferencesTab() {
+  const tabmail = document.getElementById("tabmail");
+  const prefsMode = tabmail.tabModes.preferencesTab;
+
+  if (prefsMode.tabs.length == 1) {
+    tabmail.selectedTab = prefsMode.tabs[0];
+  } else {
+    openOptionsDialog();
+  }
+
+  is(prefsMode.tabs.length, 1, "preferences tab is open");
+  is(tabmail.selectedTab, prefsMode.tabs[0], "preferences tab is selected");
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+async function closeAddressBookTab() {
+  let tabmail = document.getElementById("tabmail");
+  let abMode = tabmail.tabModes.addressBookTab;
+
+  if (abMode.tabs.length == 1) {
+    tabmail.closeTab(abMode.tabs[0]);
+  }
+
+  is(abMode.tabs.length, 0, "address book tab is not open");
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+async function closePreferencesTab() {
+  let tabmail = document.getElementById("tabmail");
+  let prefsMode = tabmail.tabModes.preferencesTab;
+
+  if (prefsMode.tabs.length == 1) {
+    tabmail.closeTab(prefsMode.tabs[0]);
+  }
+
+  is(prefsMode.tabs.length, 0, "preferences tab is not open");
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+async function openAddonsTab() {
+  const tabmail = document.getElementById("tabmail");
+  const contentMode = tabmail.tabModes.contentTab;
+
+  if (contentMode.tabs.length == 1) {
+    tabmail.selectedTab = contentMode.tabs[0];
+  } else {
+    openAddonsMgr("addons://list/extension");
+  }
+
+  is(contentMode.tabs.length, 1, "addons tab is open");
+  is(tabmail.selectedTab, contentMode.tabs[0], "addons tab is selected");
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+async function closeAddonsTab() {
+  let tabmail = document.getElementById("tabmail");
+  let contentMode = tabmail.tabModes.contentTab;
+
+  if (contentMode.tabs.length == 1) {
+    tabmail.closeTab(contentMode.tabs[0]);
+  }
+
+  is(contentMode.tabs.length, 0, "addons tab is not open");
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+/**
+ * Create a calendar using the "Create New Calendar" dialog.
+ *
+ * @param {string} name - Name for the new calendar.
+ * @param {object} [data] - Data to enter into the dialog.
+ * @param {boolean} [data.showReminders] - False to disable reminders.
+ * @param {string} [data.email] - An email address.
+ * @param {object} [data.network] - Data for network calendars.
+ * @param {string} [data.network.location] - A URI (leave undefined for local ICS file).
+ * @param {boolean} [data.network.offline] - False to disable the cache.
+ */
+async function createCalendarUsingDialog(name, data = {}) {
+  /**
+   * Callback function to interact with the dialog.
+   *
+   * @param {nsIDOMWindow} win - The dialog window.
+   */
+  async function useDialog(win) {
+    let doc = win.document;
+    let dialogElement = doc.querySelector("dialog");
+    let acceptButton = dialogElement.getButton("accept");
+
+    if (data.network) {
+      // Choose network calendar type.
+      doc.querySelector("#calendar-type [value='network']").click();
+      acceptButton.click();
+
+      // Enter a location.
+      if (data.network.location == undefined) {
+        let calendarFile = Services.dirsvc.get("TmpD", Ci.nsIFile);
+        calendarFile.append(name + ".ics");
+        let fileURI = Services.io.newFileURI(calendarFile);
+        data.network.location = fileURI.prePath + fileURI.pathQueryRef;
+      }
+      EventUtils.synthesizeMouseAtCenter(doc.querySelector("#network-location-input"), {}, win);
+      EventUtils.sendString(data.network.location, win);
+
+      // Choose offline support.
+      if (data.network.offline == undefined) {
+        data.network.offline = true;
+      }
+      let offlineCheckbox = doc.querySelector("#network-cache-checkbox");
+      if (!offlineCheckbox.checked) {
+        EventUtils.synthesizeMouseAtCenter(offlineCheckbox, {}, win);
+      }
+      acceptButton.click();
+
+      // Set up an observer to wait for calendar(s) to be found, before
+      // clicking the accept button to subscribe to the calendar(s).
+      let observer = new MutationObserver(mutationList => {
+        mutationList.forEach(async mutation => {
+          if (mutation.type === "childList") {
+            acceptButton.click();
+          }
+        });
+      });
+      observer.observe(doc.querySelector("#network-calendar-list"), { childList: true });
+    } else {
+      // Choose local calendar type.
+      doc.querySelector("#calendar-type [value='local']").click();
+      acceptButton.click();
+
+      // Set calendar name.
+      // Setting the value does not activate the accept button on all platforms,
+      // so we need to type something in case the field is empty.
+      let nameInput = doc.querySelector("#local-calendar-name-input");
+      if (nameInput.value == "") {
+        EventUtils.synthesizeMouseAtCenter(nameInput, {}, win);
+        EventUtils.sendString(name, win);
+      }
+
+      // Set reminder option.
+      if (data.showReminders == undefined) {
+        data.showReminders = true;
+      }
+      let localFireAlarmsCheckbox = doc.querySelector("#local-fire-alarms-checkbox");
+      if (localFireAlarmsCheckbox.checked != data.showReminders) {
+        EventUtils.synthesizeMouseAtCenter(localFireAlarmsCheckbox, {}, win);
+      }
+
+      // Set email account.
+      if (data.email == undefined) {
+        data.email = "none";
+      }
+      let emailIdentityMenulist = doc.querySelector("#email-identity-menulist");
+      EventUtils.synthesizeMouseAtCenter(emailIdentityMenulist, {}, win);
+      emailIdentityMenulist.querySelector("menuitem[value='none']").click();
+
+      // Create the calendar.
+      acceptButton.click();
+    }
+  }
+
+  let dialogWindowPromise = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-creation.xhtml",
+    { callback: useDialog }
+  );
+  // Open the "create new calendar" dialog.
+  CalendarTestUtils.openCalendarTab(window);
+  // This double-click must be inside the calendar list but below the list items.
+  EventUtils.synthesizeMouseAtCenter(document.querySelector("#calendar-list"), { clickCount: 2 });
+  return dialogWindowPromise;
+}
+
+const calendarViewsInitialState = CalendarTestUtils.saveCalendarViewsState(window);
+
+registerCleanupFunction(async () => {
+  await CalendarTestUtils.restoreCalendarViewsState(window, calendarViewsInitialState);
+  await closeTasksTab();
+  await closeChatTab();
+  await closeAddressBookTab();
+  await closePreferencesTab();
+  await closeAddonsTab();
+
+  // Close any event or task tabs that are open.
+  let tabmail = document.getElementById("tabmail");
+  let eventTabPanelIds = tabmail.tabModes.calendarEvent.tabs.map(tab => tab.panel.id);
+  let taskTabPanelIds = tabmail.tabModes.calendarTask.tabs.map(tab => tab.panel.id);
+  for (let id of eventTabPanelIds) {
+    await closeCalendarEventTab(id);
+  }
+  for (let id of taskTabPanelIds) {
+    await closeCalendarTaskTab(id);
+  }
+  Services.prefs.setBoolPref("calendar.item.editInTab", false);
+
+  Assert.equal(tabmail.tabInfo.length, 1, "all tabs closed");
+});
diff --git a/comm/calendar/test/browser/invitations/browser.ini b/comm/calendar/test/browser/invitations/browser.ini
new file mode 100644
index 0000000000..7c7aa6af46
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser.ini
@@ -0,0 +1,31 @@
+[default]
+head = ../head.js head.js
+prefs =
+  calendar.item.promptDelete=false
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+  calendar.week.start=0
+  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
+support-files = data/**
+
+[browser_attachedPublishEvent.js]
+[browser_icsAttachment.js]
+skip-if = os == 'win'
+[browser_identityPrompt.js]
+[browser_imipBar.js]
+[browser_imipBarCancel.js]
+[browser_imipBarEmail.js]
+[browser_imipBarExceptionCancel.js]
+[browser_imipBarExceptionOnly.js]
+[browser_imipBarExceptions.js]
+[browser_imipBarRepeat.js]
+[browser_imipBarRepeatCancel.js]
+[browser_imipBarRepeatUpdates.js]
+[browser_imipBarUpdates.js]
+[browser_invitationDisplayNew.js]
+[browser_unsupportedFreq.js]
diff --git a/comm/calendar/test/browser/invitations/browser_attachedPublishEvent.js b/comm/calendar/test/browser/invitations/browser_attachedPublishEvent.js
new file mode 100644
index 0000000000..af121a8032
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_attachedPublishEvent.js
@@ -0,0 +1,72 @@
+/* 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/. */
+
+/**
+ * Test that attached events - NOT invites - works properly.
+ * These are attached VCALENDARs that have METHOD:PUBLISH.
+ */
+"use strict";
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var gCalendar;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  let receiverAcct = MailServices.accounts.createAccount();
+  receiverAcct.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  let receiverIdentity = MailServices.accounts.createIdentity();
+  receiverIdentity.email = "john.doe@example.com";
+  receiverAcct.addIdentity(receiverIdentity);
+  gCalendar = CalendarTestUtils.createCalendar("EventTestCal");
+
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(gCalendar);
+    MailServices.accounts.removeAccount(receiverAcct, true);
+  });
+});
+
+/**
+ * Test that opening a message containing an event with iTIP method "PUBLISH"
+ * shows the correct UI.
+ * The party crashing dialog should not show.
+ */
+add_task(async function test_event_from_eml() {
+  let file = new FileUtils.File(getTestFilePath("data/message-non-invite.eml"));
+
+  let win = await openMessageFromFile(file);
+  let aboutMessage = win.document.getElementById("messageBrowser").contentWindow;
+  let imipBar = aboutMessage.document.getElementById("imip-bar");
+
+  await TestUtils.waitForCondition(() => !imipBar.collapsed);
+  info("Ok, iMIP bar is showing");
+
+  let imipAddButton = aboutMessage.document.getElementById("imipAddButton");
+  Assert.ok(!imipAddButton.hidden, "Add button should show");
+
+  EventUtils.synthesizeMouseAtCenter(imipAddButton, {}, aboutMessage);
+
+  // Make sure the event got added, without showing the party crashing dialog.
+  await TestUtils.waitForCondition(async () => {
+    let event = await gCalendar.getItem("1e5fd4e6-bc52-439c-ac76-40da54f57c77@secure.example.com");
+    return event;
+  });
+
+  await TestUtils.waitForCondition(() => imipAddButton.hidden, "Add button should hide");
+
+  let imipDetailsButton = aboutMessage.document.getElementById("imipDetailsButton");
+  Assert.ok(!imipDetailsButton.hidden, "Details button should show");
+
+  await BrowserTestUtils.closeWindow(win);
+});
diff --git a/comm/calendar/test/browser/invitations/browser_icsAttachment.js b/comm/calendar/test/browser/invitations/browser_icsAttachment.js
new file mode 100644
index 0000000000..11bde9144d
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_icsAttachment.js
@@ -0,0 +1,71 @@
+/* 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/. */
+
+/**
+ * Test TB can be set as default calendar app.
+ */
+
+/**
+ * Set TB as default calendar app.
+ */
+add_setup(function () {
+  let shellSvc = Cc["@mozilla.org/mail/shell-service;1"].getService(Ci.nsIShellService);
+  shellSvc.setDefaultClient(false, shellSvc.CALENDAR);
+  ok(shellSvc.isDefaultClient(false, shellSvc.CALENDAR), "setDefaultClient works");
+});
+
+/**
+ * Test when opening an ics attachment, TB should be shown as an option.
+ */
+add_task(async function test_ics_attachment() {
+  let file = new FileUtils.File(getTestFilePath("data/message-containing-event.eml"));
+  let msgWindow = await openMessageFromFile(file);
+  let aboutMessage = msgWindow.document.getElementById("messageBrowser").contentWindow;
+  let promise = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://mozapps/content/downloads/unknownContentType.xhtml",
+    {
+      async callback(dialogWindow) {
+        ok(true, "unknownContentType dialog opened");
+        let dialogElement = dialogWindow.document.querySelector("dialog");
+        let acceptButton = dialogElement.getButton("accept");
+        return new Promise(resolve => {
+          let observer = new MutationObserver(mutationList => {
+            mutationList.forEach(async mutation => {
+              if (mutation.attributeName == "disabled" && !acceptButton.disabled) {
+                is(acceptButton.disabled, false, "Accept button enabled");
+                if (AppConstants.platform != "macosx") {
+                  let bundle = Services.strings.createBundle(
+                    "chrome://branding/locale/brand.properties"
+                  );
+                  let name = bundle.GetStringFromName("brandShortName");
+                  // macOS requires extra step in Finder to set TB as default calendar app.
+                  ok(
+                    dialogWindow.document.getElementById("openHandler").label.includes(name),
+                    `${name} is the default calendar app`
+                  );
+                }
+
+                // Should really click acceptButton and test
+                // calender-ics-file-dialog is opened. But on local, a new TB
+                // instance is started and this test will fail.
+                dialogElement.getButton("cancel").click();
+                resolve();
+              }
+            });
+          });
+          observer.observe(acceptButton, { attributes: true });
+        });
+      },
+    }
+  );
+  EventUtils.synthesizeMouseAtCenter(
+    aboutMessage.document.getElementById("attachmentName"),
+    {},
+    aboutMessage
+  );
+  await promise;
+
+  await BrowserTestUtils.closeWindow(msgWindow);
+});
diff --git a/comm/calendar/test/browser/invitations/browser_identityPrompt.js b/comm/calendar/test/browser/invitations/browser_identityPrompt.js
new file mode 100644
index 0000000000..e2d6fe3115
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_identityPrompt.js
@@ -0,0 +1,144 @@
+/* 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/. */
+
+/**
+ * Tests for the calender-itip-identity dialog.
+ */
+
+"use strict";
+
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+var { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+let receiverAcct;
+let receiverIdentity;
+let gInbox;
+let calendar;
+
+registerCleanupFunction(() => {
+  CalendarTestUtils.removeCalendar(calendar);
+  MailServices.accounts.removeIncomingServer(receiverAcct.incomingServer, true);
+  MailServices.accounts.removeAccount(receiverAcct);
+});
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  if (MailServices.accounts.accounts.length == 0) {
+    MailServices.accounts.createLocalMailAccount();
+  }
+
+  let rootFolder = MailServices.accounts.localFoldersServer.rootFolder;
+  if (!rootFolder.containsChildNamed("Inbox")) {
+    rootFolder.createSubfolder("Inbox", null);
+  }
+  gInbox = rootFolder.getChildNamed("Inbox");
+
+  receiverAcct = MailServices.accounts.createAccount();
+  receiverAcct.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  receiverIdentity = MailServices.accounts.createIdentity();
+  receiverIdentity.email = "receiver@example.com";
+  receiverAcct.addIdentity(receiverIdentity);
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+
+  let copyListener = new PromiseTestUtils.PromiseCopyListener();
+  MailServices.copy.copyFileMessage(
+    new FileUtils.File(getTestFilePath("data/meet-meeting-invite.eml")),
+    gInbox,
+    null,
+    false,
+    0,
+    "",
+    copyListener,
+    null
+  );
+  await copyListener.promise;
+});
+
+/**
+ * Tests that the identity prompt shows when accepting an invitation to an
+ * event with an identity no calendar is configured to use.
+ */
+add_task(async function testInvitationIdentityPrompt() {
+  let tabmail = document.getElementById("tabmail");
+  let about3Pane = tabmail.currentAbout3Pane;
+  about3Pane.displayFolder(gInbox.URI);
+  about3Pane.threadTree.selectedIndex = 0;
+
+  let dialogPromise = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-itip-identity-dialog.xhtml",
+    {
+      async callback(win) {
+        // Select the identity we want to use.
+        let menulist = win.document.getElementById("identity-menu");
+        for (let i = 0; i < menulist.itemCount; i++) {
+          let target = menulist.getItemAtIndex(i);
+          if (target.value == receiverIdentity.fullAddress) {
+            menulist.selectedIndex = i;
+          }
+        }
+
+        win.document.querySelector("dialog").getButton("accept").click();
+      },
+    }
+  );
+
+  // Override this function to intercept the attempt to send the email out.
+  let sendItemsArgs = [];
+  let getImipTransport = cal.itip.getImipTransport;
+  cal.itip.getImipTransport = () => ({
+    scheme: "mailto",
+    type: "email",
+    sendItems(receipientArray, item, sender) {
+      sendItemsArgs = [receipientArray, item, sender];
+      return true;
+    },
+  });
+
+  let aboutMessage = tabmail.currentAboutMessage;
+  let acceptButton = aboutMessage.document.getElementById("imipAcceptButton");
+  await TestUtils.waitForCondition(
+    () => BrowserTestUtils.is_visible(acceptButton),
+    "waiting for accept button to become visible"
+  );
+  EventUtils.synthesizeMouseAtCenter(acceptButton, {}, aboutMessage);
+  await dialogPromise;
+
+  let event;
+  await TestUtils.waitForCondition(async () => {
+    event = await calendar.getItem("65m17hsdolmotv3kvmrtg40ont@google.com");
+    return event && sendItemsArgs.length;
+  });
+
+  // Restore this function.
+  cal.itip.getImipTransport = getImipTransport;
+
+  let id = `mailto:${receiverIdentity.email}`;
+  Assert.ok(event, "event was added to the calendar successfully");
+  Assert.ok(event.getAttendeeById(id), "selected identity was added to the attendee list");
+  Assert.equal(
+    event.getProperty("X-MOZ-INVITED-ATTENDEE"),
+    id,
+    "X-MOZ-INVITED-ATTENDEE is set to the selected identity"
+  );
+
+  let [recipientArray, , sender] = sendItemsArgs;
+  Assert.equal(recipientArray.length, 1, "one recipient for the reply");
+  Assert.equal(recipientArray[0].id, "mailto:example@gmail.com", "recipient is event organizer");
+  Assert.equal(sender.id, id, "sender is the identity selected");
+});
diff --git a/comm/calendar/test/browser/invitations/browser_imipBar.js b/comm/calendar/test/browser/invitations/browser_imipBar.js
new file mode 100644
index 0000000000..c9a21a6d2b
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_imipBar.js
@@ -0,0 +1,199 @@
+/* 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/. */
+
+/**
+ * Tests for receiving event invitations via the imip-bar.
+ */
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { CalItipDefaultEmailTransport } = ChromeUtils.import(
+  "resource:///modules/CalItipEmailTransport.jsm"
+);
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+let identity;
+let calendar;
+let transport;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  let account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  identity = MailServices.accounts.createIdentity();
+  identity.email = "receiver@example.com";
+  account.addIdentity(identity);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.createDateTime("20220316T191602Z"));
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+  transport = new EmailTransport(account, identity);
+
+  let getImipTransport = cal.itip.getImipTransport;
+  cal.itip.getImipTransport = () => transport;
+
+  let deleteMgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(
+    Ci.calIDeletedItems
+  ).wrappedJSObject;
+  let markDeleted = deleteMgr.markDeleted;
+  deleteMgr.markDeleted = () => {};
+
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeAccount(account, true);
+    cal.itip.getImipTransport = getImipTransport;
+    deleteMgr.markDeleted = markDeleted;
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+});
+
+/**
+ * Tests accepting an invitation and sending a response.
+ */
+add_task(async function testAcceptWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  await clickAction(win, "imipAcceptButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "ACCEPTED",
+    },
+    event
+  );
+
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests tentatively accepting an invitation and sending a response.
+ */
+add_task(async function testTentativeWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  await clickAction(win, "imipTentativeButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "TENTATIVE",
+    },
+    event
+  );
+
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests declining an invitation and sending a response.
+ */
+add_task(async function testDeclineWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  await clickAction(win, "imipDeclineButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "DECLINED",
+    },
+    event
+  );
+
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests accepting an invitation without sending a response.
+ */
+add_task(async function testAcceptWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  await clickMenuAction(win, "imipAcceptButton", "imipAcceptButton_AcceptDontSend");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "ACCEPTED",
+      noReply: true,
+    },
+    event
+  );
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests tentatively accepting an invitation without sending a response.
+ */
+add_task(async function testTentativeWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  await clickMenuAction(win, "imipTentativeButton", "imipTentativeButton_TentativeDontSend");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "TENTATIVE",
+      noReply: true,
+    },
+    event
+  );
+
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests declining an invitation without sending a response.
+ */
+add_task(async function testDeclineWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  await clickMenuAction(win, "imipDeclineButton", "imipDeclineButton_DeclineDontSend");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "DECLINED",
+      noReply: true,
+    },
+    event
+  );
+
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
diff --git a/comm/calendar/test/browser/invitations/browser_imipBarCancel.js b/comm/calendar/test/browser/invitations/browser_imipBarCancel.js
new file mode 100644
index 0000000000..3cde7d4656
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_imipBarCancel.js
@@ -0,0 +1,129 @@
+/* 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/. */
+
+/**
+ * Tests for processing cancellations via the imip-bar.
+ */
+
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+let identity;
+let calendar;
+let transport;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  let account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  identity = MailServices.accounts.createIdentity();
+  identity.email = "receiver@example.com";
+  account.addIdentity(identity);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.createDateTime("20220316T191602Z"));
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+  transport = new EmailTransport(account, identity);
+
+  let getImipTransport = cal.itip.getImipTransport;
+  cal.itip.getImipTransport = () => transport;
+
+  let deleteMgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(
+    Ci.calIDeletedItems
+  ).wrappedJSObject;
+  let markDeleted = deleteMgr.markDeleted;
+  deleteMgr.markDeleted = () => {};
+
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeAccount(account, true);
+    cal.itip.getImipTransport = getImipTransport;
+    deleteMgr.markDeleted = markDeleted;
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+});
+
+/**
+ * Tests accepting a cancellation to an already accepted event.
+ */
+add_task(async function testCancelAccepted() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipAcceptButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await BrowserTestUtils.closeWindow(win);
+  await doCancelTest({
+    transport,
+    calendar,
+    event,
+  });
+});
+
+/**
+ * Tests accepting a cancellation to tentatively accepted event.
+ */
+add_task(async function testCancelTentative() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipTentativeButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await BrowserTestUtils.closeWindow(win);
+  await doCancelTest({
+    transport,
+    calendar,
+    event,
+  });
+});
+
+/**
+ * Tests accepting a cancellation to an already declined event.
+ */
+add_task(async function testCancelDeclined() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipDeclineButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await BrowserTestUtils.closeWindow(win);
+  await doCancelTest({
+    transport,
+    calendar,
+    event,
+  });
+});
+
+/**
+ * Tests the handling of a cancellation when the event was not processed
+ * previously.
+ */
+add_task(async function testUnprocessedCancel() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/cancel-single-event.eml"));
+  let win = await openImipMessage(invite);
+
+  // There should be no buttons present because there is no action to take.
+  // Note: the imip-bar message "This message contains an event that has already been processed" is
+  // misleading.
+  for (let button of [...win.document.querySelectorAll("#imip-view-toolbar > toolbarbutton")]) {
+    Assert.ok(button.hidden, `${button.id} is hidden`);
+  }
+  await BrowserTestUtils.closeWindow(win);
+});
diff --git a/comm/calendar/test/browser/invitations/browser_imipBarEmail.js b/comm/calendar/test/browser/invitations/browser_imipBarEmail.js
new file mode 100644
index 0000000000..a3816b65dd
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_imipBarEmail.js
@@ -0,0 +1,168 @@
+/* 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/. */
+
+/**
+ * Test that the IMIP bar behaves properly for eml files with invites.
+ */
+
+/* eslint-disable @microsoft/sdl/no-insecure-url */
+
+function getFileFromChromeURL(leafName) {
+  let ChromeRegistry = Cc["@mozilla.org/chrome/chrome-registry;1"].getService(Ci.nsIChromeRegistry);
+
+  let url = Services.io.newURI(getRootDirectory(gTestPath) + leafName);
+  info(url.spec);
+  let fileURL = ChromeRegistry.convertChromeURL(url).QueryInterface(Ci.nsIFileURL);
+  return fileURL.file;
+}
+
+/**
+ * Test that when opening a message containing a Teams meeting invite
+ * works as it should.
+ */
+add_task(async function test_event_from_eml() {
+  let file = getFileFromChromeURL("data/teams-meeting-invite.eml");
+
+  let msgWindow = await openMessageFromFile(file);
+  let aboutMessage = msgWindow.document.getElementById("messageBrowser").contentWindow;
+
+  await TestUtils.waitForCondition(
+    () => !aboutMessage.document.getElementById("imip-bar").collapsed
+  );
+  info("Ok, iMIP bar is showing");
+
+  // The contentDocument has both the imipHTMLDetails HTML part generated by us,
+  // and the regular HTML part generated by the sender (the server).
+  let links = [
+    ...msgWindow.content.document.getElementById("imipHTMLDetails").querySelectorAll("a"),
+  ];
+
+  Assert.equal(links.length, 3, "The 3 links should show");
+
+  // Check the links and their text
+  Assert.equal(
+    links[0].href,
+    "https://teams.microsoft.com/l/meetup-join/19%3ameeting_MGU5NmI2ZGYtOWZmOC00Y2ZmLWJlOTItNjUxNjA5YjUyYTYy%40thread.v2/0?context=%7b%22Tid%22%3a%222fd0c1c5-28e1-40c4-9f0d-a0363ca80a3c%22%2c%22Oid%22%3a%2214464d09-ceb8-458c-a61c-717f1e5c66c5%22%7d",
+    "link0 href"
+  );
+  Assert.equal(
+    links[0].textContent,
+    "<https://teams.microsoft.com/l/meetup-join/19%3ameeting_MGU5NmI2ZGYtOWZmOC00Y2ZmLWJlOTItNjUxNjA5YjUyYTYy%40thread.v2/0?context=%7b%22Tid%22%3a%222fd0c1c5-28e1-40c4-9f0d-a0363ca80a3c%22%2c%22Oid%22%3a%2214464d09-ceb8-458c-a61c-717f1e5c66c5%22%7d>",
+    "link0 textContent"
+  );
+
+  Assert.equal(links[1].href, "https://aka.ms/JoinTeamsMeeting", "link1 href");
+  Assert.equal(links[1].textContent, "<https://aka.ms/JoinTeamsMeeting>", "link1 textContent");
+
+  Assert.equal(
+    links[2].href,
+    "https://teams.microsoft.com/meetingOptions/?organizerId=14464d09-ceb8-458c-a61c-717f1e5c66c5&tenantId=2fd0c1c5-28e1-40c4-9f0d-a0363ca80a3c&threadId=19_meeting_MGU5NmI2ZGYtOWZmOC00Y2ZmLWJlOTItNjUxNjA5YjUyYTYy@thread.v2&messageId=0&language=fi-FI",
+    "link2 href"
+  );
+  Assert.equal(
+    links[2].textContent,
+    "<https://teams.microsoft.com/meetingOptions/?organizerId=14464d09-ceb8-458c-a61c-717f1e5c66c5&tenantId=2fd0c1c5-28e1-40c4-9f0d-a0363ca80a3c&threadId=19_meeting_MGU5NmI2ZGYtOWZmOC00Y2ZmLWJlOTItNjUxNjA5YjUyYTYy@thread.v2&messageId=0&language=fi-FI>",
+    "link2 textContent"
+  );
+
+  await BrowserTestUtils.closeWindow(msgWindow);
+
+  Assert.ok(true, "test_event_from_eml test ran to completion");
+});
+
+/**
+ * Test that when opening a message containing a Meet meeting invite
+ * works as it should.
+ */
+add_task(async function test_event_from_eml() {
+  let file = getFileFromChromeURL("data/meet-meeting-invite.eml");
+
+  let msgWindow = await openMessageFromFile(file);
+  let aboutMessage = msgWindow.document.getElementById("messageBrowser").contentWindow;
+
+  await TestUtils.waitForCondition(
+    () => !aboutMessage.document.getElementById("imip-bar").collapsed
+  );
+  info("Ok, iMIP bar is showing");
+
+  // The contentDocument has both the imipHTMLDetails HTML part generated by us,
+  // and the regular HTML part generated by the sender (the server).
+  let links = [
+    ...msgWindow.content.document.getElementById("imipHTMLDetails").querySelectorAll("a"),
+  ];
+
+  Assert.equal(links.length, 4, "The 4 links should show");
+
+  // Check the links and their text
+  Assert.equal(links[0].href, "mailto:foo@example.com", "link0 href");
+  Assert.equal(links[0].textContent, "<foo@example.com>", "link0 textContent");
+
+  Assert.equal(links[1].href, "http://example.com/?foo=bar", "link1 href");
+  Assert.equal(links[1].textContent, "http://example.com?foo=bar", "link1 textContent");
+
+  Assert.equal(links[2].href, "https://meet.google.com/pyb-ndcu-hhc", "link1 href");
+  Assert.equal(links[2].textContent, "https://meet.google.com/pyb-ndcu-hhc", "link1 textContent");
+
+  Assert.equal(
+    links[3].href,
+    "https://calendar.google.com/calendar/event?action=VIEW&eid=NjVtMTdoc2RvbG1vdHYza3ZtcnRnNDBvbnQgbWFnbnVzLm1lbGluQGh1dC5maQ&tok=MjEjYmVydGF0aGVib3RAZ21haWwuY29tZTg2NGFjYmNjYWE1MjVlZWJmY2UzYmRmMDAyNWU0MDkzNDAxZjRhZg&ctz=Europe%2FHelsinki&hl=sv&es=1",
+    "link2 href"
+  );
+  Assert.equal(
+    links[3].textContent,
+    "https://calendar.google.com/calendar/event?action=VIEW&eid=NjVtMTdoc2RvbG1vdHYza3ZtcnRnNDBvbnQgbWFnbnVzLm1lbGluQGh1dC5maQ&tok=MjEjYmVydGF0aGVib3RAZ21haWwuY29tZTg2NGFjYmNjYWE1MjVlZWJmY2UzYmRmMDAyNWU0MDkzNDAxZjRhZg&ctz=Europe%2FHelsinki&hl=sv&es=1",
+    "link2 textContent"
+  );
+
+  await BrowserTestUtils.closeWindow(msgWindow);
+
+  Assert.ok(true, "test_event_from_eml test ran to completion");
+});
+
+/**
+ * Test that when opening a message containing an outlook invite with "empty"
+ * content works as it should.
+ */
+add_task(async function test_outlook_event_from_eml() {
+  let file = getFileFromChromeURL("data/outlook-test-invite.eml");
+
+  let msgWindow = await openMessageFromFile(file);
+  let aboutMessage = msgWindow.document.getElementById("messageBrowser").contentWindow;
+
+  await TestUtils.waitForCondition(
+    () => !aboutMessage.document.getElementById("imip-bar").collapsed
+  );
+  info("Ok, iMIP bar is showing");
+
+  let details = msgWindow.content.document.getElementById("imipHTMLDetails");
+
+  Assert.equal(
+    details.getAttribute("open"),
+    "open",
+    "Details should be expanded when the message doesn't include good details"
+  );
+
+  await BrowserTestUtils.closeWindow(msgWindow);
+
+  Assert.ok(true, "test_outlook_event_from_eml test ran to completion");
+});
+
+/**
+ * Test that when opening a message containing an event, the IMIP bar shows.
+ */
+add_task(async function test_event_from_eml() {
+  let file = getFileFromChromeURL("data/message-containing-event.eml");
+
+  let msgWindow = await openMessageFromFile(file);
+  let aboutMessage = msgWindow.document.getElementById("messageBrowser").contentWindow;
+
+  await TestUtils.waitForCondition(
+    () => !aboutMessage.document.getElementById("imip-bar").collapsed
+  );
+  info("Ok, iMIP bar is showing");
+
+  await BrowserTestUtils.closeWindow(msgWindow);
+
+  Assert.ok(true, "test_event_from_eml test ran to completion");
+});
diff --git a/comm/calendar/test/browser/invitations/browser_imipBarExceptionCancel.js b/comm/calendar/test/browser/invitations/browser_imipBarExceptionCancel.js
new file mode 100644
index 0000000000..7800e742ca
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_imipBarExceptionCancel.js
@@ -0,0 +1,137 @@
+/* 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/. */
+
+/**
+ * Tests for processing cancellations to recurring event exceptions.
+ */
+
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+let identity;
+let calendar;
+let transport;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  requestLongerTimeout(3);
+  let account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  identity = MailServices.accounts.createIdentity();
+  identity.email = "receiver@example.com";
+  account.addIdentity(identity);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.createDateTime("20220316T191602Z"));
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+  transport = new EmailTransport(account, identity);
+  let getImipTransport = cal.itip.getImipTransport;
+  cal.itip.getImipTransport = () => transport;
+
+  let deleteMgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(
+    Ci.calIDeletedItems
+  ).wrappedJSObject;
+
+  let markDeleted = deleteMgr.markDeleted;
+  deleteMgr.markDeleted = () => {};
+
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeAccount(account, true);
+    cal.itip.getImipTransport = getImipTransport;
+    deleteMgr.markDeleted = markDeleted;
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+});
+
+/**
+ * Tests cancelling an exception works.
+ */
+add_task(async function testCancelException() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    await doCancelExceptionTest({
+      calendar,
+      transport,
+      identity,
+      partStat,
+      recurrenceId: "20220317T110000Z",
+      isRecurring: true,
+    });
+  }
+});
+
+/**
+ * Tests cancelling an event with only an exception processed works.
+ */
+add_task(async function testCancelExceptionOnly() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    let win = await openImipMessage(
+      new FileUtils.File(getTestFilePath("data/exception-major.eml"))
+    );
+    await clickAction(win, actionIds.single.button[partStat]);
+
+    let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 5, 1)).item;
+    await BrowserTestUtils.closeWindow(win);
+    await doCancelTest({
+      calendar,
+      event,
+      transport,
+      identity,
+    });
+  }
+});
+
+/**
+ * Tests processing a cancellation for a recurring event works when only an
+ * exception was processed previously.
+ */
+add_task(async function testCancelSeriesWithExceptionOnly() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    let win = await openImipMessage(
+      new FileUtils.File(getTestFilePath("data/exception-major.eml"))
+    );
+    await clickMenuAction(
+      win,
+      actionIds.single.button[partStat],
+      actionIds.single.noReply[partStat]
+    );
+
+    let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 5, 1)).item;
+    await BrowserTestUtils.closeWindow(win);
+
+    let cancel = new FileUtils.File(getTestFilePath("data/cancel-repeat-event.eml"));
+    let cancelWin = await openImipMessage(cancel);
+    let aboutMessage = cancelWin.document.getElementById("messageBrowser").contentWindow;
+
+    let deleteButton = aboutMessage.document.getElementById("imipDeleteButton");
+    Assert.ok(!deleteButton.hidden, `#${deleteButton.id} button shown`);
+    EventUtils.synthesizeMouseAtCenter(deleteButton, {}, aboutMessage);
+    await BrowserTestUtils.closeWindow(cancelWin);
+    await CalendarTestUtils.monthView.waitForNoItemAt(window, 3, 5, 1);
+    Assert.ok(!(await calendar.getItem(event.id)), "event was deleted");
+
+    Assert.equal(
+      transport.sentItems.length,
+      0,
+      "itip subsystem did not attempt to send a response"
+    );
+    Assert.equal(transport.sentMsgs.length, 0, "no call was made into the mail subsystem");
+  }
+});
diff --git a/comm/calendar/test/browser/invitations/browser_imipBarExceptionOnly.js b/comm/calendar/test/browser/invitations/browser_imipBarExceptionOnly.js
new file mode 100644
index 0000000000..88ad0b3c41
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_imipBarExceptionOnly.js
@@ -0,0 +1,262 @@
+/* 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/. */
+
+/**
+ * Tests for receiving an invitation exception but the original event was not
+ * processed first.
+ */
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+let identity;
+let calendar;
+let transport;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  requestLongerTimeout(5);
+  let account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  identity = MailServices.accounts.createIdentity();
+  identity.email = "receiver@example.com";
+  account.addIdentity(identity);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.createDateTime("20220316T191602Z"));
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+  transport = new EmailTransport(account, identity);
+
+  let getImipTransport = cal.itip.getImipTransport;
+  cal.itip.getImipTransport = () => transport;
+
+  let deleteMgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(
+    Ci.calIDeletedItems
+  ).wrappedJSObject;
+  let markDeleted = deleteMgr.markDeleted;
+  deleteMgr.markDeleted = () => {};
+
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeAccount(account, true);
+    cal.itip.getImipTransport = getImipTransport;
+    deleteMgr.markDeleted = markDeleted;
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+});
+
+/**
+ * Tests accepting a minor exception and sending a response.
+ */
+add_task(async function testMinorAcceptWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-minor.eml")));
+  await clickAction(win, "imipAcceptButton");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "ACCEPTED",
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests tentatively accepting a minor exception and sending a response.
+ */
+add_task(async function testMinorTentativeWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-minor.eml")));
+  await clickAction(win, "imipTentativeButton");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "TENTATIVE",
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests declining a minor exception and sending a response.
+ */
+add_task(async function testMinorDeclineWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-minor.eml")));
+  await clickAction(win, "imipDeclineButton");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "DECLINED",
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests accepting a minor exception without sending a response.
+ */
+add_task(async function testMinorAcceptWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-minor.eml")));
+  await clickMenuAction(win, "imipAcceptButton", "imipAcceptButton_AcceptDontSend");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "ACCEPTED",
+    noReply: true,
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests tentatively accepting a minor exception without sending a response.
+ */
+add_task(async function testMinorTentativeWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-minor.eml")));
+  await clickMenuAction(win, "imipTentativeButton", "imipTentativeButton_TentativeDontSend");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "TENTATIVE",
+    noReply: true,
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests declining a minor exception without sending a response.
+ */
+add_task(async function testMinorDeclineWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-minor.eml")));
+  await clickMenuAction(win, "imipDeclineButton", "imipDeclineButton_DeclineDontSend");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "DECLINED",
+    noReply: true,
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests accepting a major exception and sending a response.
+ */
+add_task(async function testMajorAcceptWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-major.eml")));
+  await clickAction(win, "imipAcceptButton");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "ACCEPTED",
+    isMajor: true,
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests tentatively accepting a major exception and sending a response.
+ */
+add_task(async function testMajorTentativeWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-major.eml")));
+  await clickAction(win, "imipTentativeButton");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "TENTATIVE",
+    isMajor: true,
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests declining a major exception and sending a response.
+ */
+add_task(async function testMajorDeclineWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-major.eml")));
+  await clickAction(win, "imipDeclineButton");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "DECLINED",
+    isMajor: true,
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests accepting a major exception without sending a response.
+ */
+add_task(async function testMajorAcceptWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-major.eml")));
+  await clickMenuAction(win, "imipAcceptButton", "imipAcceptButton_AcceptDontSend");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "ACCEPTED",
+    noReply: true,
+    isMajor: true,
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests tentatively accepting a major exception without sending a response.
+ */
+add_task(async function testMajorTentativeWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-major.eml")));
+  await clickMenuAction(win, "imipTentativeButton", "imipTentativeButton_TentativeDontSend");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "TENTATIVE",
+    noReply: true,
+    isMajor: true,
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests declining a major exception without sending a response.
+ */
+add_task(async function testMajorDeclineWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-major.eml")));
+  await clickMenuAction(win, "imipDeclineButton", "imipDeclineButton_DeclineDontSend");
+  await doExceptionOnlyTest({
+    calendar,
+    transport,
+    identity,
+    partStat: "DECLINED",
+    noReply: true,
+    isMajor: true,
+  });
+  await BrowserTestUtils.closeWindow(win);
+});
diff --git a/comm/calendar/test/browser/invitations/browser_imipBarExceptions.js b/comm/calendar/test/browser/invitations/browser_imipBarExceptions.js
new file mode 100644
index 0000000000..2cdf18ed59
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_imipBarExceptions.js
@@ -0,0 +1,288 @@
+/* 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/. */
+
+/**
+ * Tests for handling exceptions to recurring event invitations via the imip-bar.
+ */
+
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+let identity;
+let calendar;
+let transport;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  requestLongerTimeout(5);
+  let account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  identity = MailServices.accounts.createIdentity();
+  identity.email = "receiver@example.com";
+  account.addIdentity(identity);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.createDateTime("20220316T191602Z"));
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+  transport = new EmailTransport(account, identity);
+  let getImipTransport = cal.itip.getImipTransport;
+  cal.itip.getImipTransport = () => transport;
+
+  let deleteMgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(
+    Ci.calIDeletedItems
+  ).wrappedJSObject;
+
+  let markDeleted = deleteMgr.markDeleted;
+  deleteMgr.markDeleted = () => {};
+
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeAccount(account, true);
+    cal.itip.getImipTransport = getImipTransport;
+    deleteMgr.markDeleted = markDeleted;
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+});
+
+/**
+ * Tests a minor update exception to an already accepted recurring event.
+ */
+add_task(async function testMinorUpdateExceptionToAccepted() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipAcceptRecurrencesButton");
+
+  await BrowserTestUtils.closeWindow(win);
+  await doMinorExceptionTest({
+    transport,
+    calendar,
+    partStat: "ACCEPTED",
+  });
+});
+
+/**
+ * Tests a minor update exception to an already tentatively accepted recurring
+ * event.
+ */
+add_task(async function testMinorUpdateExceptionToTentative() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipTentativeRecurrencesButton");
+
+  await BrowserTestUtils.closeWindow(win);
+  await doMinorExceptionTest({
+    transport,
+    calendar,
+    partStat: "TENTATIVE",
+  });
+});
+
+/**
+ * Tests a minor update exception to an already declined recurring declined
+ * event.
+ */
+add_task(async function testMinorUpdateExceptionToDeclined() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipDeclineRecurrencesButton");
+
+  await BrowserTestUtils.closeWindow(win);
+  await doMinorExceptionTest({
+    transport,
+    calendar,
+    partStat: "DECLINED",
+  });
+});
+
+/**
+ * Tests a major update exception to an already accepted event.
+ */
+add_task(async function testMajorExceptionToAcceptedWithResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipAcceptRecurrencesButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorExceptionTest({
+      transport,
+      identity,
+      calendar,
+      partStat,
+    });
+  }
+});
+
+/**
+ * Tests a major update exception to an already tentatively accepted event.
+ */
+add_task(async function testMajorExceptionToTentativeWithResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipTentativeRecurrencesButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorExceptionTest({
+      transport,
+      identity,
+      calendar,
+      partStat,
+    });
+  }
+});
+
+/**
+ * Tests a major update exception to an already declined event.
+ */
+add_task(async function testMajorExceptionToDeclinedWithResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipDeclineRecurrencesButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorExceptionTest({
+      transport,
+      identity,
+      calendar,
+      isRecurring: true,
+      partStat,
+    });
+  }
+});
+
+/**
+ * Tests a major update exception to an already accepted event without sending
+ * a reply.
+ */
+add_task(async function testMajorExecptionToAcceptedWithoutResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickMenuAction(
+      win,
+      "imipAcceptRecurrencesButton",
+      "imipAcceptRecurrencesButton_AcceptDontSend"
+    );
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorExceptionTest({
+      transport,
+      calendar,
+      isRecurring: true,
+      partStat,
+      noReply: true,
+    });
+  }
+});
+
+/**
+ * Tests a major update exception to an already tentatively accepted event
+ * without sending a reply.
+ */
+add_task(async function testMajorUpdateToTentativeWithoutResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickMenuAction(
+      win,
+      "imipTentativeRecurrencesButton",
+      "imipTentativeRecurrencesButton_TentativeDontSend"
+    );
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorExceptionTest({
+      transport,
+      calendar,
+      isRecurring: true,
+      partStat,
+      noReply: true,
+    });
+  }
+});
+
+/**
+ * Tests a major update exception to a declined event without sending a reply.
+ */
+add_task(async function testMajorUpdateToDeclinedWithoutResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickMenuAction(
+      win,
+      "imipDeclineRecurrencesButton",
+      "imipDeclineRecurrencesButton_DeclineDontSend"
+    );
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorExceptionTest({
+      transport,
+      calendar,
+      isRecurring: true,
+      partStat,
+      noReply: true,
+    });
+  }
+});
+
+/**
+ * Tests a major update exception to an event where the participation status
+ * is still "NEEDS-ACTION". Here we want to ensure action is only taken on the
+ * target exception date and not the other dates.
+ */
+add_task(async function testMajorUpdateToNeedsAction() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+
+    // Extract the event from the .eml file and manually add it to the calendar.
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let srcText = await IOUtils.readUTF8(invite.path);
+    let ics = srcText.match(
+      /--00000000000080f3da05db4aef59[\S\s]+--00000000000080f3da05db4aef59/g
+    )[0];
+    ics = ics.split("--00000000000080f3da05db4aef59").join("");
+    ics = ics.replaceAll(/Content-(Type|Transfer-Encoding)?: .*/g, "");
+
+    let event = new CalEvent(ics);
+
+    // This will not be set because we manually added the event.
+    event.setProperty("x-moz-received-dtstamp", "20220316T191602Z");
+
+    await calendar.addItem(event);
+    await CalendarTestUtils.monthView.waitForItemAt(window, 3, 5, 1).item;
+    await doMajorExceptionTest({
+      transport,
+      identity,
+      calendar,
+      isRecurring: true,
+      partStat,
+    });
+  }
+});
diff --git a/comm/calendar/test/browser/invitations/browser_imipBarRepeat.js b/comm/calendar/test/browser/invitations/browser_imipBarRepeat.js
new file mode 100644
index 0000000000..c14ff2c0a5
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_imipBarRepeat.js
@@ -0,0 +1,218 @@
+/* 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/. */
+
+/**
+ * Tests for receiving recurring event invitations via the imip-bar.
+ */
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+let identity;
+let calendar;
+let transport;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  let account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  identity = MailServices.accounts.createIdentity();
+  identity.email = "receiver@example.com";
+  account.addIdentity(identity);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.createDateTime("20220316T191602Z"));
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+  transport = new EmailTransport(account, identity);
+
+  let getImipTransport = cal.itip.getImipTransport;
+  cal.itip.getImipTransport = () => transport;
+
+  let deleteMgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(
+    Ci.calIDeletedItems
+  ).wrappedJSObject;
+  let markDeleted = deleteMgr.markDeleted;
+  deleteMgr.markDeleted = () => {};
+
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeAccount(account, true);
+    cal.itip.getImipTransport = getImipTransport;
+    deleteMgr.markDeleted = markDeleted;
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+});
+
+/**
+ * Tests accepting an invitation to a recurring event and sending a response.
+ */
+add_task(async function testAcceptRecurringWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickAction(win, "imipAcceptRecurrencesButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      isRecurring: true,
+      partStat: "ACCEPTED",
+    },
+    event
+  );
+
+  await calendar.deleteItem(event.parentItem);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests tentatively accepting an invitation to a recurring event and sending a
+ * response.
+ */
+add_task(async function testTentativeRecurringWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickAction(win, "imipTentativeRecurrencesButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      isRecurring: true,
+      partStat: "TENTATIVE",
+    },
+    event
+  );
+
+  await calendar.deleteItem(event.parentItem);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests declining an invitation to a recurring event and sending a response.
+ */
+add_task(async function testDeclineRecurringWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickAction(win, "imipDeclineRecurrencesButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      isRecurring: true,
+      partStat: "DECLINED",
+    },
+    event
+  );
+
+  await calendar.deleteItem(event.parentItem);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests accepting an invitation to a recurring event without sending a response.
+ */
+add_task(async function testAcceptRecurringWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickMenuAction(
+    win,
+    "imipAcceptRecurrencesButton",
+    "imipAcceptRecurrencesButton_AcceptDontSend"
+  );
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      isRecurring: true,
+      partStat: "ACCEPTED",
+      noReply: true,
+    },
+    event
+  );
+
+  await calendar.deleteItem(event.parentItem);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests tentatively accepting an invitation to a recurring event without sending
+ * a response.
+ */
+add_task(async function testTentativeRecurringWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickMenuAction(
+    win,
+    "imipTentativeRecurrencesButton",
+    "imipTentativeRecurrencesButton_TentativeDontSend"
+  );
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      isRecurring: true,
+      partStat: "TENTATIVE",
+      noReply: true,
+    },
+    event
+  );
+
+  await calendar.deleteItem(event.parentItem);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests declining an invitation to a recurring event without sending a response.
+ */
+add_task(async function testDeclineRecurrencesWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickMenuAction(
+    win,
+    "imipDeclineRecurrencesButton",
+    "imipDeclineRecurrencesButton_DeclineDontSend"
+  );
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      isRecurring: true,
+      partStat: "DECLINED",
+      noReply: true,
+    },
+    event
+  );
+
+  await calendar.deleteItem(event.parentItem);
+  await BrowserTestUtils.closeWindow(win);
+});
diff --git a/comm/calendar/test/browser/invitations/browser_imipBarRepeatCancel.js b/comm/calendar/test/browser/invitations/browser_imipBarRepeatCancel.js
new file mode 100644
index 0000000000..1ab50cc739
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_imipBarRepeatCancel.js
@@ -0,0 +1,186 @@
+/* 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/. */
+
+/**
+ * Tests for processing cancellations to recurring invitations via the imip-bar.
+ */
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+let identity;
+let calendar;
+let transport;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  requestLongerTimeout(5);
+  let account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  identity = MailServices.accounts.createIdentity();
+  identity.email = "receiver@example.com";
+  account.addIdentity(identity);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.createDateTime("20220316T191602Z"));
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+  transport = new EmailTransport(account, identity);
+
+  let getImipTransport = cal.itip.getImipTransport;
+  cal.itip.getImipTransport = () => transport;
+
+  let deleteMgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(
+    Ci.calIDeletedItems
+  ).wrappedJSObject;
+  let markDeleted = deleteMgr.markDeleted;
+  deleteMgr.markDeleted = () => {};
+
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeAccount(account, true);
+    cal.itip.getImipTransport = getImipTransport;
+    deleteMgr.markDeleted = markDeleted;
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+});
+
+/**
+ * Tests accepting a cancellation to an already accepted recurring event.
+ */
+add_task(async function testCancelAcceptedRecurring() {
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickAction(win, "imipAcceptRecurrencesButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await BrowserTestUtils.closeWindow(win);
+  await doCancelTest({
+    calendar,
+    event,
+    transport,
+    isRecurring: true,
+  });
+});
+
+/**
+ * Tests accepting a cancellation to an already tentatively accepted event.
+ */
+add_task(async function testCancelTentativeRecurring() {
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickAction(win, "imipTentativeRecurrencesButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await BrowserTestUtils.closeWindow(win);
+  await doCancelTest({
+    calendar,
+    event,
+    transport,
+    identity,
+    isRecurring: true,
+  });
+});
+
+/**
+ * Tests accepting a cancellation to an already declined recurring event.
+ */
+add_task(async function testCancelDeclinedRecurring() {
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickAction(win, "imipDeclineRecurrencesButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await BrowserTestUtils.closeWindow(win);
+  await doCancelTest({
+    calendar,
+    event,
+    transport,
+    identity,
+    isRecurring: true,
+  });
+});
+
+/**
+ * Tests accepting a cancellation to a single occurrence of an already accepted
+ * recurring event.
+ */
+add_task(async function testCancelAcceptedOccurrence() {
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickAction(win, "imipAcceptRecurrencesButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await BrowserTestUtils.closeWindow(win);
+  await doCancelTest({
+    calendar,
+    event,
+    transport,
+    isRecurring: true,
+    recurrenceId: "20220317T110000Z",
+  });
+  await calendar.deleteItem(event.parentItem);
+});
+
+/**
+ * Tests accepting a cancellation to a single occurrence of an already tentatively
+ * accepted event.
+ */
+add_task(async function testCancelTentativeOccurrence() {
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickAction(win, "imipTentativeRecurrencesButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await BrowserTestUtils.closeWindow(win);
+  await doCancelTest({
+    calendar,
+    event,
+    transport,
+    identity,
+    isRecurring: true,
+    recurrenceId: "20220317T110000Z",
+  });
+  await calendar.deleteItem(event.parentItem);
+});
+
+/**
+ * Tests accepting a cancellation to a single occurrence of an already declined
+ * recurring event.
+ */
+add_task(async function testCancelDeclinedOccurrence() {
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/repeat-event.eml")));
+  await clickAction(win, "imipDeclineRecurrencesButton");
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await BrowserTestUtils.closeWindow(win);
+  await doCancelTest({
+    calendar,
+    event,
+    transport,
+    identity,
+    isRecurring: true,
+    recurrenceId: "20220317T110000Z",
+  });
+  await calendar.deleteItem(event.parentItem);
+});
+
+/**
+ * Tests the handling of a cancellation when the event was not processed
+ * previously.
+ */
+add_task(async function testUnprocessedCancel() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/cancel-repeat-event.eml"));
+  let win = await openImipMessage(invite);
+  for (let button of [...win.document.querySelectorAll("#imip-view-toolbar > toolbarbutton")]) {
+    Assert.ok(button.hidden, `${button.id} is hidden`);
+  }
+  await BrowserTestUtils.closeWindow(win);
+});
diff --git a/comm/calendar/test/browser/invitations/browser_imipBarRepeatUpdates.js b/comm/calendar/test/browser/invitations/browser_imipBarRepeatUpdates.js
new file mode 100644
index 0000000000..7f0d16f627
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_imipBarRepeatUpdates.js
@@ -0,0 +1,247 @@
+/* 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/. */
+
+/**
+ * Tests for receiving minor and major updates to recurring event invitations
+ * via the imip-bar.
+ */
+
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+let identity;
+let calendar;
+let transport;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  requestLongerTimeout(5);
+  let account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  identity = MailServices.accounts.createIdentity();
+  identity.email = "receiver@example.com";
+  account.addIdentity(identity);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.createDateTime("20220316T191602Z"));
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+  transport = new EmailTransport(account, identity);
+  let getImipTransport = cal.itip.getImipTransport;
+  cal.itip.getImipTransport = () => transport;
+
+  let deleteMgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(
+    Ci.calIDeletedItems
+  ).wrappedJSObject;
+  let markDeleted = deleteMgr.markDeleted;
+  deleteMgr.markDeleted = () => {};
+
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeAccount(account, true);
+    cal.itip.getImipTransport = getImipTransport;
+    deleteMgr.markDeleted = markDeleted;
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+});
+
+/**
+ * Tests a minor update to an already accepted event.
+ */
+add_task(async function testMinorUpdateToAccepted() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipAcceptRecurrencesButton");
+
+  await BrowserTestUtils.closeWindow(win);
+  await doMinorUpdateTest({
+    transport,
+    calendar,
+    isRecurring: true,
+    partStat: "ACCEPTED",
+  });
+});
+
+/**
+ * Tests a minor update to an already tentatively accepted event.
+ */
+add_task(async function testMinorUpdateToTentative() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipTentativeRecurrencesButton");
+
+  await BrowserTestUtils.closeWindow(win);
+  await doMinorUpdateTest({
+    transport,
+    calendar,
+    isRecurring: true,
+    partStat: "TENTATIVE",
+  });
+});
+
+/**
+ * Tests a minor update to an already declined event.
+ */
+add_task(async function testMinorUpdateToDeclined() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipDeclineRecurrencesButton");
+
+  await BrowserTestUtils.closeWindow(win);
+  await doMinorUpdateTest({ transport, calendar, isRecurring: true, invite, partStat: "DECLINED" });
+});
+
+/**
+ * Tests a major update to an already accepted event.
+ */
+add_task(async function testMajorUpdateToAcceptedWithResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipAcceptRecurrencesButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      identity,
+      calendar,
+      isRecurring: true,
+      partStat,
+    });
+  }
+});
+
+/**
+ * Tests a major update to an already tentatively accepted event.
+ */
+add_task(async function testMajorUpdateToTentativeWithResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipTentativeRecurrencesButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      identity,
+      calendar,
+      isRecurring: true,
+      partStat,
+    });
+  }
+});
+
+/**
+ * Tests a major update to an already declined event.
+ */
+add_task(async function testMajorUpdateToDeclinedWithResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipDeclineRecurrencesButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      identity,
+      calendar,
+      isRecurring: true,
+      partStat,
+    });
+  }
+});
+
+/**
+ * Tests a major update to an already accepted event without replying to the
+ * update.
+ */
+add_task(async function testMajorUpdateToAcceptedWithoutResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickMenuAction(
+      win,
+      "imipAcceptRecurrencesButton",
+      "imipAcceptRecurrencesButton_AcceptDontSend"
+    );
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      calendar,
+      isRecurring: true,
+      partStat,
+      noReply: true,
+    });
+  }
+});
+
+/**
+ * Tests a major update to an already tentatively accepted event without replying
+ * to the update.
+ */
+add_task(async function testMajorUpdateToTentativeWithoutResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickMenuAction(
+      win,
+      "imipTentativeRecurrencesButton",
+      "imipTentativeRecurrencesButton_TentativeDontSend"
+    );
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      calendar,
+      isRecurring: true,
+      partStat,
+      noReply: true,
+    });
+  }
+});
+
+/**
+ * Tests a major update to an already declined event.
+ */
+add_task(async function testMajorUpdateToDeclinedWithoutResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickMenuAction(
+      win,
+      "imipDeclineRecurrencesButton",
+      "imipDeclineRecurrencesButton_DeclineDontSend"
+    );
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      calendar,
+      isRecurring: true,
+      partStat,
+      noReply: true,
+    });
+  }
+});
diff --git a/comm/calendar/test/browser/invitations/browser_imipBarUpdates.js b/comm/calendar/test/browser/invitations/browser_imipBarUpdates.js
new file mode 100644
index 0000000000..d0f5018e89
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_imipBarUpdates.js
@@ -0,0 +1,223 @@
+/* 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/. */
+
+/**
+ * Tests for receiving minor and major updates to invitations via the imip-bar.
+ */
+
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+let identity;
+let calendar;
+let transport;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  requestLongerTimeout(5);
+  let account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  identity = MailServices.accounts.createIdentity();
+  identity.email = "receiver@example.com";
+  account.addIdentity(identity);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.createDateTime("20220316T191602Z"));
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+  transport = new EmailTransport(account, identity);
+
+  let getImipTransport = cal.itip.getImipTransport;
+  cal.itip.getImipTransport = () => transport;
+
+  let deleteMgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(
+    Ci.calIDeletedItems
+  ).wrappedJSObject;
+  let markDeleted = deleteMgr.markDeleted;
+  deleteMgr.markDeleted = () => {};
+
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeAccount(account, true);
+    cal.itip.getImipTransport = getImipTransport;
+    deleteMgr.markDeleted = markDeleted;
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+});
+
+/**
+ * Tests a minor update to an already accepted event.
+ */
+add_task(async function testMinorUpdateToAccepted() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipAcceptButton");
+
+  await BrowserTestUtils.closeWindow(win);
+  await doMinorUpdateTest({
+    transport,
+    calendar,
+    partStat: "ACCEPTED",
+  });
+});
+
+/**
+ * Tests a minor update to an already tentatively accepted event.
+ */
+add_task(async function testMinorUpdateToTentative() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipTentativeButton");
+
+  await BrowserTestUtils.closeWindow(win);
+  await doMinorUpdateTest({ transport, calendar, invite, partStat: "TENTATIVE" });
+});
+
+/**
+ * Tests a minor update to an already declined event.
+ */
+add_task(async function testMinorUpdateToDeclined() {
+  transport.reset();
+  let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, "imipDeclineButton");
+
+  await BrowserTestUtils.closeWindow(win);
+  await doMinorUpdateTest({ transport, calendar, invite, partStat: "DECLINED" });
+});
+
+/**
+ * Tests a major update to an already accepted event.
+ */
+add_task(async function testMajorUpdateToAcceptedWithResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipAcceptButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      identity,
+      calendar,
+      partStat,
+    });
+  }
+});
+
+/**
+ * Tests a major update to an already tentatively accepted event.
+ */
+add_task(async function testMajorUpdateToTentativeWithResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipTentativeButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      identity,
+      calendar,
+      partStat,
+    });
+  }
+});
+
+/**
+ * Tests a major update to an already declined event.
+ */
+add_task(async function testMajorUpdateToDeclinedWithResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipDeclineButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      identity,
+      calendar,
+      partStat,
+    });
+  }
+});
+
+/**
+ * Tests a major update to an already accepted event without replying to the
+ * update.
+ */
+add_task(async function testMajorUpdateToAcceptedWithoutResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipAcceptButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      calendar,
+      partStat,
+      noReply: true,
+    });
+  }
+});
+
+/**
+ * Tests a major update to an already tentatively accepted event without replying
+ * to the update.
+ */
+add_task(async function testMajorUpdateToTentativeWithoutResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipTentativeButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      calendar,
+      partStat,
+      noReply: true,
+    });
+  }
+});
+
+/**
+ * Tests a major update to an already declined event.
+ */
+add_task(async function testMajorUpdateToDeclinedWithoutResponse() {
+  for (let partStat of ["ACCEPTED", "TENTATIVE", "DECLINED"]) {
+    transport.reset();
+    let invite = new FileUtils.File(getTestFilePath("data/single-event.eml"));
+    let win = await openImipMessage(invite);
+    await clickAction(win, "imipDeclineButton");
+
+    await BrowserTestUtils.closeWindow(win);
+    await doMajorUpdateTest({
+      transport,
+      calendar,
+      partStat,
+      noReply: true,
+    });
+  }
+});
diff --git a/comm/calendar/test/browser/invitations/browser_invitationDisplayNew.js b/comm/calendar/test/browser/invitations/browser_invitationDisplayNew.js
new file mode 100644
index 0000000000..a7b3f833de
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_invitationDisplayNew.js
@@ -0,0 +1,257 @@
+/* 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/. */
+
+/**
+ * Tests for the invitation panel display with new events.
+ */
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { CalItipDefaultEmailTransport } = ChromeUtils.import(
+  "resource:///modules/CalItipEmailTransport.jsm"
+);
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+let identity;
+let calendar;
+let transport;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  let account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+  identity = MailServices.accounts.createIdentity();
+  identity.email = "receiver@example.com";
+  account.addIdentity(identity);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.createDateTime("20220316T191602Z"));
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+  transport = new EmailTransport(account, identity);
+
+  let getImipTransport = cal.itip.getImipTransport;
+  cal.itip.getImipTransport = () => transport;
+
+  let deleteMgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(
+    Ci.calIDeletedItems
+  ).wrappedJSObject;
+  let markDeleted = deleteMgr.markDeleted;
+  deleteMgr.markDeleted = () => {};
+
+  Services.prefs.setBoolPref("calendar.itip.newInvitationDisplay", true);
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeAccount(account, true);
+    cal.itip.getImipTransport = getImipTransport;
+    deleteMgr.markDeleted = markDeleted;
+    CalendarTestUtils.removeCalendar(calendar);
+    Services.prefs.setBoolPref("calendar.itip.newInvitationDisplay", false);
+  });
+});
+
+/**
+ * Tests the invitation panel shows the correct data when loaded with a new
+ * invitation.
+ */
+add_task(async function testShowPanelData() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  let panel = win.document
+    .getElementById("messageBrowser")
+    .contentDocument.querySelector("calendar-invitation-panel");
+
+  if (panel.ownerDocument.hasPendingL10nMutations) {
+    await BrowserTestUtils.waitForEvent(panel.ownerDocument, "L10nMutationsFinished");
+  }
+
+  let notification = panel.shadowRoot.querySelector("notification-message");
+  compareShownPanelValues(notification.shadowRoot, {
+    ".notification-message": "You have been invited to this event.",
+    ".notification-button-container > button": "More",
+  });
+
+  compareShownPanelValues(panel.shadowRoot, {
+    "#title": "Single Event",
+    "#location": "Somewhere",
+    "#partStatTotal": "3 participants",
+    '[data-l10n-id="calendar-invitation-panel-partstat-accepted"]': "1 yes",
+    '[data-l10n-id="calendar-invitation-panel-partstat-needs-action"]': "2 pending",
+    "#attendees li:nth-of-type(1)": "Sender <sender@example.com>",
+    "#attendees li:nth-of-type(2)": "Receiver <receiver@example.com>",
+    "#attendees li:nth-of-type(3)": "Other <other@example.com>",
+    "#description": "An event invitation.",
+  });
+
+  Assert.ok(!panel.shadowRoot.querySelector("#actionButtons").hidden, "action buttons shown");
+  for (let indicator of [
+    ...panel.shadowRoot.querySelectorAll("calendar-invitation-change-indicator"),
+  ]) {
+    Assert.ok(indicator.hidden, `${indicator.id} is hidden`);
+  }
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests accepting an invitation and sending a response.
+ */
+add_task(async function testAcceptWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  let panel = win.document
+    .getElementById("messageBrowser")
+    .contentDocument.querySelector("calendar-invitation-panel");
+
+  await clickPanelAction(panel, "acceptButton");
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "ACCEPTED",
+    },
+    event
+  );
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests tentatively accepting an invitation and sending a response.
+ */
+add_task(async function testTentativeWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  let panel = win.document
+    .getElementById("messageBrowser")
+    .contentDocument.querySelector("calendar-invitation-panel");
+
+  await clickPanelAction(panel, "tentativeButton");
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "TENTATIVE",
+    },
+    event
+  );
+
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests declining an invitation and sending a response.
+ */
+add_task(async function testDeclineWithResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  let panel = win.document
+    .getElementById("messageBrowser")
+    .contentDocument.querySelector("calendar-invitation-panel");
+
+  await clickPanelAction(panel, "declineButton");
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "DECLINED",
+    },
+    event
+  );
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests accepting an invitation without sending a response.
+ */
+add_task(async function testAcceptWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  let panel = win.document
+    .getElementById("messageBrowser")
+    .contentDocument.querySelector("calendar-invitation-panel");
+
+  await clickPanelAction(panel, "acceptButton", false);
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "ACCEPTED",
+      noSend: true,
+    },
+    event
+  );
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests tentatively accepting an invitation without sending a response.
+ */
+add_task(async function testTentativeWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  let panel = win.document
+    .getElementById("messageBrowser")
+    .contentDocument.querySelector("calendar-invitation-panel");
+
+  await clickPanelAction(panel, "tentativeButton", false);
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "TENTATIVE",
+      noSend: true,
+    },
+    event
+  );
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Tests declining an invitation without sending a response.
+ */
+add_task(async function testDeclineWithoutResponse() {
+  transport.reset();
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/single-event.eml")));
+  let panel = win.document
+    .getElementById("messageBrowser")
+    .contentDocument.querySelector("calendar-invitation-panel");
+
+  await clickPanelAction(panel, "declineButton", false);
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+  await doImipBarActionTest(
+    {
+      calendar,
+      transport,
+      identity,
+      partStat: "DECLINED",
+      noSend: true,
+    },
+    event
+  );
+  await calendar.deleteItem(event);
+  await BrowserTestUtils.closeWindow(win);
+});
diff --git a/comm/calendar/test/browser/invitations/browser_unsupportedFreq.js b/comm/calendar/test/browser/invitations/browser_unsupportedFreq.js
new file mode 100644
index 0000000000..2d05ed66dc
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/browser_unsupportedFreq.js
@@ -0,0 +1,107 @@
+/* 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/. */
+
+/**
+ * Tests for ensuring the application does not hang after processing an
+ * unsupported FREQ value.
+ */
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+let calendar;
+
+/**
+ * Initialize account, identity and calendar.
+ */
+add_setup(async function () {
+  let account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "receiver",
+    "example.com",
+    "imap"
+  );
+
+  let identity = MailServices.accounts.createIdentity();
+  identity.email = "receiver@example.com";
+  account.addIdentity(identity);
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  window.goToDate(cal.createDateTime("20220316T191602Z"));
+
+  calendar = CalendarTestUtils.createCalendar("Test");
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeAccount(account, true);
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+});
+
+/**
+ * Runs the test using the provided FREQ value.
+ *
+ * @param {string} freq Either "SECONDLY" or "MINUTELY"
+ */
+async function doFreqTest(freq) {
+  let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+  let srcText = await IOUtils.readUTF8(invite.path);
+  let tmpFile = FileTestUtils.getTempFile(`${freq}.eml`);
+
+  srcText = srcText.replace(/RRULE:.*/g, `RRULE:FREQ=${freq}`);
+  srcText = srcText.replace(/UID:.*/g, `UID:${freq}`);
+  await IOUtils.writeUTF8(tmpFile.path, srcText);
+
+  let win = await openImipMessage(tmpFile);
+  await clickMenuAction(
+    win,
+    "imipAcceptRecurrencesButton",
+    "imipAcceptRecurrencesButton_AcceptDontSend"
+  );
+
+  // Give the view time to refresh and create any occurrences.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(resolve => setTimeout(resolve, 5000));
+  await BrowserTestUtils.closeWindow(win);
+
+  let dayBoxItems = document.querySelectorAll("calendar-month-day-box-item");
+  Assert.equal(dayBoxItems.length, 1, "only one occurrence displayed");
+
+  let [dayBox] = dayBoxItems;
+  let { item } = dayBox;
+  Assert.equal(item.title, "Repeat Event");
+  Assert.equal(item.startDate.icalString, "20220316T110000Z");
+
+  let summaryDialog = await CalendarTestUtils.viewItem(window, dayBox);
+  Assert.equal(
+    summaryDialog.document.querySelector(".repeat-details").textContent,
+    "Repeat details unknown",
+    "repeat details not shown"
+  );
+
+  await BrowserTestUtils.closeWindow(summaryDialog);
+  await calendar.deleteItem(item.parentItem);
+  await TestUtils.waitForCondition(
+    () => document.querySelectorAll("calendar-month-day-box-item").length == 0
+  );
+}
+
+/**
+ * Tests accepting an invitation using the FREQ=SECONDLY value does not render
+ * the application unusable.
+ */
+add_task(async function testSecondly() {
+  return doFreqTest("SECONDLY");
+});
+
+/**
+ * Tests accepting an invitation using the FREQ=MINUTELY value does not render
+ * the application unusable.
+ */
+add_task(async function testMinutely() {
+  return doFreqTest("MINUTELY");
+});
diff --git a/comm/calendar/test/browser/invitations/data/cancel-repeat-event.eml b/comm/calendar/test/browser/invitations/data/cancel-repeat-event.eml
new file mode 100644
index 0000000000..03f298525b
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/cancel-repeat-event.eml
@@ -0,0 +1,49 @@
+MIME-Version: 1.0

+Date: Mon, 28 Mar 2022 17:49:35 +0000

+Subject: Invitation: Repeat Event @ Daily from 2pm to 3pm 3 times (AST) (receiver@example.com)

+From: sender@example.com

+To: receiver@example.com

+Content-Type: multipart/mixed; boundary="00000000000080f3db05db4aef5b"

+

+--00000000000080f3db05db4aef5b

+Content-Type: multipart/alternative; boundary="00000000000080f3da05db4aef59"

+

+--00000000000080f3da05db4aef59

+Content-Type: text/calendar; charset="UTF-8"; method=CANCEL

+Content-Transfer-Encoding: 7bit

+

+BEGIN:VCALENDAR

+METHOD:CANCEL

+BEGIN:VEVENT

+DTSTART:20220316T110000Z

+DTEND:20220316T113000Z

+RRULE:FREQ=DAILY;WKST=SU;COUNT=3;INTERVAL=1

+DTSTAMP:20220316T191602Z

+UID:02e79b96

+ORGANIZER;CN=Sender;

+ EMAIL=sender@example.com:mailto:sender@example.com

+ATTENDEE;CN=Sender;

+ EMAIL=sender@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=ACCEPTED:mailto:sender@example.com

+ATTENDEE;CN=Receiver;EMAIL=receiver@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION:mailto:receiver@example.com

+ATTENDEE;CN=Other;EMAIL=other@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION:mailto:other@example.com

+CREATED:20220328T174934Z

+LAST-MODIFIED:20220328T174934Z

+LOCATION:Somewhere

+SEQUENCE:1

+STATUS:CANCELLED

+SUMMARY:Repeat Event

+DESCRIPTION:An event invitation.

+TRANSP:OPAQUE

+BEGIN:VALARM

+ACTION:DISPLAY

+TRIGGER:-P1D

+DESCRIPTION:This is an event reminder

+END:VALARM

+END:VEVENT

+END:VCALENDAR

+

+--00000000000080f3da05db4aef59--

+--00000000000080f3db05db4aef5b--

diff --git a/comm/calendar/test/browser/invitations/data/cancel-single-event.eml b/comm/calendar/test/browser/invitations/data/cancel-single-event.eml
new file mode 100644
index 0000000000..afb4edb99d
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/cancel-single-event.eml
@@ -0,0 +1,78 @@
+MIME-Version: 1.0
+Content-Transfer-Encoding: binary
+Content-Type: multipart/mixed; boundary="_----------=_1647458162153312762582"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+To: receiver@example.com
+Subject: Cancellation: Single Event @ Wed, Mar 16 2022 11:00 AST
+From: Sender <sender@example.com>
+
+This is a multi-part message in MIME format.
+
+--_----------=_1647458162153312762582
+MIME-Version: 1.0
+Content-Transfer-Encoding: binary
+Content-Type: multipart/alternative; boundary="_----------=_1647458162153312762583"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+This is a multi-part message in MIME format.
+
+--_----------=_1647458162153312762583
+MIME-Version: 1.0
+Content-Disposition: inline
+Content-Length: 227
+Content-Transfer-Encoding: binary
+Content-Type: text/plain; charset="utf-8"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+Single Event
+
+When:
+    Wed, Mar 16 2022
+    11:00 - 12:00 AST
+Where:
+    Somewhere
+
+--_----------=_1647458162153312762583
+MIME-Version: 1.0
+Content-Disposition: inline
+Content-Transfer-Encoding: quoted-printable
+Content-Type: text/calendar; charset="utf-8"; method=CANCEL
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+BEGIN:VCALENDAR
+VERSION:2.0
+METHOD:CANCEL
+CALSCALE:GREGORIAN
+BEGIN:VEVENT
+UID:02e79b96
+SEQUENCE:1
+DTSTAMP:20220317T191602Z
+CREATED:20220316T191532Z
+DTSTART:20220316T110000Z
+DTEND:20220316T113000Z
+DURATION:PT1H
+PRIORITY:0
+SUMMARY:Single Event
+DESCRIPTION:An event invitation.
+LOCATION:Somewhere
+STATUS:CANCELLED
+TRANSP:OPAQUE
+CLASS:PUBLIC
+ORGANIZER;CN=3DSender;
+ EMAIL=3Dsender@example.com:mailto:sender@example.com
+ATTENDEE;CN=3DSender;
+ EMAIL=3Dsender@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DACCEPTED:mailto:sender@example.com
+ATTENDEE;CN=Receiver;EMAIL=3Dreceiver@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DNEEDS-ACTION:mailto:receiver@example.com
+ATTENDEE;CN=Other;EMAIL=other@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DNEEDS-ACTION:mailto:other@example.com
+BEGIN:VALARM
+ACTION:DISPLAY
+TRIGGER:-P1D
+DESCRIPTION:This is an event reminder
+END:VALARM
+END:VEVENT
+END:VCALENDAR
+
+--_----------=_1647458162153312762583--
diff --git a/comm/calendar/test/browser/invitations/data/exception-major.eml b/comm/calendar/test/browser/invitations/data/exception-major.eml
new file mode 100644
index 0000000000..07f48e64bd
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/exception-major.eml
@@ -0,0 +1,49 @@
+MIME-Version: 1.0

+Date: Mon, 28 Mar 2022 17:49:35 +0000

+Subject: Exception Major

+From: sender@example.com

+To: receiver@example.com

+Content-Type: multipart/mixed; boundary="00000000000080f3db05db4aef5b"

+

+--00000000000080f3db05db4aef5b

+Content-Type: multipart/alternative; boundary="00000000000080f3da05db4aef59"

+

+--00000000000080f3da05db4aef59

+Content-Type: text/calendar; charset="UTF-8"; method=REQUEST

+Content-Transfer-Encoding: 7bit

+

+BEGIN:VCALENDAR

+METHOD:REQUEST

+BEGIN:VEVENT

+DTSTART:20220317T050000Z

+DTEND:20220317T053000Z

+RECURRENCE-ID:20220317T110000Z

+DTSTAMP:20220316T191602Z

+UID:02e79b96

+ORGANIZER;CN=Sender;

+ EMAIL=sender@example.com:mailto:sender@example.com

+ATTENDEE;CN=Sender;

+ EMAIL=sender@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=ACCEPTED;RSVP=FALSE:mailto:sender@example.com

+ATTENDEE;CN=Receiver;EMAIL=receiver@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:receiver@example.com

+ATTENDEE;CN=Other;EMAIL=other@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:other@example.com

+CREATED:20220328T174934Z

+LAST-MODIFIED:20220328T174934Z

+LOCATION:Somewhere

+SEQUENCE:2

+STATUS:CONFIRMED

+SUMMARY:Repeat Event

+DESCRIPTION:An event invitation.

+TRANSP:OPAQUE

+BEGIN:VALARM

+ACTION:DISPLAY

+TRIGGER:-P1D

+DESCRIPTION:This is an event reminder

+END:VALARM

+END:VEVENT

+END:VCALENDAR

+

+--00000000000080f3da05db4aef59--

+--00000000000080f3db05db4aef5b--

diff --git a/comm/calendar/test/browser/invitations/data/exception-minor.eml b/comm/calendar/test/browser/invitations/data/exception-minor.eml
new file mode 100644
index 0000000000..7cc38d29d3
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/exception-minor.eml
@@ -0,0 +1,49 @@
+MIME-Version: 1.0

+Date: Mon, 28 Mar 2022 17:49:35 +0000

+Subject: Exception Minor

+From: sender@example.com

+To: receiver@example.com

+Content-Type: multipart/mixed; boundary="00000000000080f3db05db4aef5b"

+

+--00000000000080f3db05db4aef5b

+Content-Type: multipart/alternative; boundary="00000000000080f3da05db4aef59"

+

+--00000000000080f3da05db4aef59

+Content-Type: text/calendar; charset="UTF-8"; method=REQUEST

+Content-Transfer-Encoding: 7bit

+

+BEGIN:VCALENDAR

+METHOD:REQUEST

+BEGIN:VEVENT

+DTSTART:20220317T110000Z

+DTEND:20220317T113000Z

+RECURRENCE-ID:20220317T110000Z

+DTSTAMP:20220318T191602Z

+UID:02e79b96

+ORGANIZER;CN=Sender;

+ EMAIL=sender@example.com:mailto:sender@example.com

+ATTENDEE;CN=Sender;

+ EMAIL=sender@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=ACCEPTED;RSVP=FALSE:mailto:sender@example.com

+ATTENDEE;CN=Receiver;EMAIL=receiver@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:receiver@example.com

+ATTENDEE;CN=Other;EMAIL=other@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:other@example.com

+CREATED:20220328T174934Z

+LAST-MODIFIED:20220328T174934Z

+LOCATION:Exception location

+SEQUENCE:0

+STATUS:CONFIRMED

+SUMMARY:Exception title

+DESCRIPTION:Exception description

+TRANSP:OPAQUE

+BEGIN:VALARM

+ACTION:DISPLAY

+TRIGGER:-P1D

+DESCRIPTION:Exception description.

+END:VALARM

+END:VEVENT

+END:VCALENDAR

+

+--00000000000080f3da05db4aef59--

+--00000000000080f3db05db4aef5b--

diff --git a/comm/calendar/test/browser/invitations/data/meet-meeting-invite.eml b/comm/calendar/test/browser/invitations/data/meet-meeting-invite.eml
new file mode 100644
index 0000000000..8587cd803a
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/meet-meeting-invite.eml
@@ -0,0 +1,384 @@
+Sender: Google Kalender <calendar-notification@google.com>

+Message-ID: <0000000000008c6d7005be1c767c@google.com>

+Date: Mon, 22 Mar 2021 09:12:20 +0000

+Subject: Meet invite (HTML)

+From: example@gmail.com

+To: homer@example.com

+Content-Type: multipart/mixed; boundary="0000000000008c6d6205be1c767e"

+Return-Path: example@gmail.com

+MIME-Version: 1.0

+

+--0000000000008c6d6205be1c767e

+Content-Type: multipart/alternative; boundary="0000000000008c6d6005be1c767c"

+

+--0000000000008c6d6005be1c767c

+Content-Type: text/plain; charset="UTF-8"; format=flowed; delsp=yes

+Content-Transfer-Encoding: base64

+

+RHUgaGFyIGJsaXZpdCBpbmJqdWRlbiB0aWxsIGbDtmxqYW5kZSBow6RuZGVsc2UuCgpUaXRlbDog

+TWVlZWVldCBtZSBIVE1MClRoaXMgaXMgYSB0ZXN0LiBCb2xkLiBJdGFsaWMuJm5ic3A7V2lsbCBk

+aXNjdXNzIGFkZHJlc3MgZm9yIGVtYWlsICAKJmx0O2Zvb0BleGFtcGxlLmNvbSZndDsgYW5kIGh0

+dHA6Ly9leGFtcGxlLmNvbT9mb289YmFyLgpOw6RyOiBtw6VuIGRlbiAyMiBtYXJzIDIwMjEgMTE6

+MzBhbSDigJMgMTI6MzBwbSDDlnN0ZXVyb3BlaXNrIHRpZCAtIEhlbHNpbmdmb3JzCgpBbnNsdXRu

+aW5nc2luZm86IEFuc2x1dCB0aWxsIEdvb2dsZSBNZWV0Cmh0dHBzOi8vbWVldC5nb29nbGUuY29t

+L3B5Yi1uZGN1LWhoYz9ocz0yMjQKCkthbGVuZGVyOiBob21lckBleGFtcGxlLmNvbQpWZW06CiAg

+ICAgKiBleGFtcGxlQGdtYWlsLmNvbeKAkyBvcmdhbmlzYXTDtnIKICAgICAqIGhvbWVyQGV4YW1w

+bGUuY29tCgpJbmZvcm1hdGlvbiBvbSBow6RuZGVsc2VuOiAgCmh0dHBzOi8vY2FsZW5kYXIuZ29v

+Z2xlLmNvbS9jYWxlbmRhci9ldmVudD9hY3Rpb249VklFVyZlaWQ9TmpWdE1UZG9jMlJ2YkcxdmRI

+WXphM1p0Y25Sbk5EQnZiblFnYldGbmJuVnpMbTFsYkdsdVFHaDFkQzVtYVEmdG9rPU1qRWpZbVZ5

+ZEdGMGFHVmliM1JBWjIxaGFXd3VZMjl0WlRnMk5HRmpZbU5qWVdFMU1qVmxaV0ptWTJVelltUm1N

+REF5TldVME1Ea3pOREF4WmpSaFpnJmN0ej1FdXJvcGUlMkZIZWxzaW5raSZobD1zdiZlcz0wCgpJ

+bmJqdWRhbiBmcsOlbiBHb29nbGUgS2FsZW5kZXI6IGh0dHBzOi8vY2FsZW5kYXIuZ29vZ2xlLmNv

+bS9jYWxlbmRhci8KCkRldHRhIGUtcG9zdG1lZGRlbGFuZGUgaGFyIHNraWNrYXRzIHRpbGwga29u

+dG90IGhvbWVyQGV4YW1wbGUuY29tICAKZWZ0ZXJzb20gZHUgw6RyIGRlbHRhZ2FyZSB2aWQgZGVu

+bmEgaMOkbmRlbHNlLgoKT20gZHUgaW50ZSB2aWxsIGbDpSB1cHBkYXRlcmluZ2FyIG9tIGRlbm5h

+IGjDpG5kZWxzZSBpIGZyYW10aWRlbiBrYW4gZHUgdGFja2EgIApuZWogdGlsbCBkZW5uYSBow6Ru

+ZGVsc2UuIER1IGthbiDDpHZlbiByZWdpc3RyZXJhIGRpZyBmw7ZyIGF0dCBmw6UgZXR0ICAKR29v

+Z2xlLWtvbnRvIHDDpSBodHRwczovL2NhbGVuZGFyLmdvb2dsZS5jb20vY2FsZW5kYXIvIG9jaCBr

+b250cm9sbGVyYSAgCmF2aXNlcmluZ3NpbnN0w6RsbG5pbmdhcm5hIGbDtnIgaGVsYSBrYWxlbmRl

+cm4uCgpPbSBkdSB2aWRhcmViZWZvcmRyYXIgZGVuIGjDpHIgaW5ianVkYW4ga2FuIGRldCBnw7Zy

+YSBkZXQgbcO2amxpZ3QgZsO2ciBhbGxhICAKbW90dGFnYXJlIGF0dCBza2lja2EgZXR0IHN2YXIg

+dGlsbCBvcmdhbmlzYXTDtnJlbiBvY2ggbMOkZ2dhcyB0aWxsIHDDpSAgCmfDpHN0bGlzdGFuLCBi

+anVkYSBpbiBhbmRyYSBvYXZzZXR0IGRlcmFzIGVnZW4gaW5ianVkbmluZ3NzdGF0dXMgZWxsZXIg

+IAptb2RpZmllcmEgZGl0dCBPU0EuIEzDpHMgbWVyIHDDpSAgCmh0dHBzOi8vc3VwcG9ydC5nb29n

+bGUuY29tL2NhbGVuZGFyL2Fuc3dlci8zNzEzNSNmb3J3YXJkaW5nCg==

+--0000000000008c6d6005be1c767c

+Content-Type: text/html; charset="UTF-8"

+Content-Transfer-Encoding: quoted-printable

+

+<html>

+<head>

+<meta http-equiv=3D"Content-Type" content=3D"text/html; charset=3Dutf-8">

+</head>

+<body>

+<span itemscope=3D"" itemtype=3D"http://schema.org/InformAction"><span styl=

+e=3D"display:none" itemprop=3D"about" itemscope=3D"" itemtype=3D"http://sch=

+ema.org/Person">

+<meta itemprop=3D"description" content=3D"Inbjudan fr=C3=A5n example@gm=

+ail.com">

+</span><span itemprop=3D"object" itemscope=3D"" itemtype=3D"http://schema.o=

+rg/Event">

+<div style=3D"">

+<table cellspacing=3D"0" cellpadding=3D"8" border=3D"0" summary=3D"" style=

+=3D"width:100%;font-family:Arial,Sans-serif;border:1px Solid #ccc;border-wi=

+dth:1px 2px 2px 1px;background-color:#fff;">

+<tbody>

+<tr>

+<td>

+<meta itemprop=3D"eventStatus" content=3D"http://schema.org/EventScheduled"=

+>

+<h4 style=3D"padding:6px 0;margin:0 0 4px 0;font-family:Arial,Sans-serif;fo=

+nt-size:13px;line-height:1.4;border:1px Solid #fff;background:#fff;color:#0=

+90;font-weight:normal">

+<strong>Du har blivit inbjuden till f=C3=B6ljande h=C3=A4ndelse.</strong></=

+h4>

+<div style=3D"padding:2px"><span itemprop=3D"publisher" itemscope=3D"" item=

+type=3D"http://schema.org/Organization">

+<meta itemprop=3D"name" content=3D"Google Calendar">

+</span>

+<meta itemprop=3D"eventId/googleCalendar" content=3D"65m17hsdolmotv3kvmrtg4=

+0ont">

+<h3 style=3D"padding:0 0 6px 0;margin:0;font-family:Arial,Sans-serif;font-s=

+ize:16px;font-weight:bold;color:#222">

+<span itemprop=3D"name">Meeeeet me HTML</span></h3>

+<table style=3D"display:inline-table" cellpadding=3D"0" cellspacing=3D"0" b=

+order=3D"0" summary=3D"Uppgifter om h=C3=A4ndelse">

+<tbody>

+<tr>

+<td style=3D"padding:0 1em 10px 0;font-family:Arial,Sans-serif;font-size:13=

+px;color:#888;white-space:nowrap;width:90px" valign=3D"top">

+<div><i style=3D"font-style:normal">N=C3=A4r</i></div>

+</td>

+<td style=3D"padding-bottom:10px;font-family:Arial,Sans-serif;font-size:13p=

+x;color:#222" valign=3D"top">

+<div style=3D"text-indent:-1px"><time itemprop=3D"startDate" datetime=3D"20=

+210322T093000Z"></time><time itemprop=3D"endDate" datetime=3D"20210322T1030=

+00Z"></time>m=C3=A5n den 22 mars 2021 11:30am =E2=80=93 12:30pm

+<span style=3D"color:#888">=C3=96steuropeisk tid - Helsingfors</span></div>

+</td>

+</tr>

+<tr>

+<td style=3D"padding:0 1em 4px 0;font-family:Arial,Sans-serif;font-size:13p=

+x;color:#888;white-space:nowrap;width:90px" valign=3D"top">

+<div><i style=3D"font-style:normal">Anslutningsinfo</i></div>

+</td>

+<td style=3D"padding-bottom:4px;font-family:Arial,Sans-serif;font-size:13px=

+;color:#222" valign=3D"top">

+<div style=3D"text-indent:-1px">Anslut till Google Meet</div>

+</td>

+</tr>

+<tr>

+<td style=3D"padding:0 1em 10px 0;font-family:Arial,Sans-serif;font-size:13=

+px;color:#888;white-space:nowrap;width:90px">

+</td>

+<td style=3D"padding-bottom:10px;font-family:Arial,Sans-serif;font-size:13p=

+x;color:#222" valign=3D"top">

+<div style=3D"text-indent:-1px">

+<div style=3D"text-indent:-1px"><span itemprop=3D"potentialaction" itemscop=

+e=3D"" itemtype=3D"http://schema.org/JoinAction"><span itemprop=3D"name" co=

+ntent=3D"meet.google.com/pyb-ndcu-hhc"><span itemprop=3D"target" itemscope=

+=3D"" itemtype=3D"http://schema.org/EntryPoint"><span itemprop=3D"url" cont=

+ent=3D"https://meet.google.com/pyb-ndcu-hhc?hs=3D224"><span itemprop=3D"htt=

+pMethod" content=3D"GET"><a href=3D"https://meet.google.com/pyb-ndcu-hhc?hs=

+=3D224" style=3D"color:#20c;white-space:nowrap" target=3D"_blank">meet.goog=

+le.com/pyb-ndcu-hhc</a></span></span></span></span></span>

+</div>

+</div>

+</td>

+</tr>

+<tr>

+<td style=3D"padding:0 1em 10px 0;font-family:Arial,Sans-serif;font-size:13=

+px;color:#888;white-space:nowrap;width:90px" valign=3D"top">

+<div><i style=3D"font-style:normal">Kalender</i></div>

+</td>

+<td style=3D"padding-bottom:10px;font-family:Arial,Sans-serif;font-size:13p=

+x;color:#222" valign=3D"top">

+<div style=3D"text-indent:-1px">homer@example.com</div>

+</td>

+</tr>

+<tr>

+<td style=3D"padding:0 1em 10px 0;font-family:Arial,Sans-serif;font-size:13=

+px;color:#888;white-space:nowrap;width:90px" valign=3D"top">

+<div><i style=3D"font-style:normal">Vem</i></div>

+</td>

+<td style=3D"padding-bottom:10px;font-family:Arial,Sans-serif;font-size:13p=

+x;color:#222" valign=3D"top">

+<table cellspacing=3D"0" cellpadding=3D"0">

+<tbody>

+<tr>

+<td style=3D"padding-right:10px;font-family:Arial,Sans-serif;font-size:13px=

+;color:#222;width:10px">

+<div style=3D"text-indent:-1px"><span style=3D"font-family:Courier New,mono=

+space">=E2=80=A2</span></div>

+</td>

+<td style=3D"padding-right:10px;font-family:Arial,Sans-serif;font-size:13px=

+;color:#222">

+<div style=3D"text-indent:-1px">

+<div>

+<div style=3D"margin:0 0 0.3em 0"><span itemprop=3D"attendee" itemscope=3D"=

+" itemtype=3D"http://schema.org/Person"><span itemprop=3D"name" class=3D"no=

+translate">example@gmail.com</span>

+<meta itemprop=3D"email" content=3D"example@gmail.com">

+</span><span itemprop=3D"organizer" itemscope=3D"" itemtype=3D"http://schem=

+a.org/Person">

+<meta itemprop=3D"name" content=3D"example@gmail.com">

+<meta itemprop=3D"email" content=3D"example@gmail.com">

+</span><span style=3D"font-size:11px;color:#888">=E2=80=93 organisat=C3=B6r=

+</span></div>

+</div>

+</div>

+</td>

+</tr>

+<tr>

+<td style=3D"padding-right:10px;font-family:Arial,Sans-serif;font-size:13px=

+;color:#222;width:10px">

+<div style=3D"text-indent:-1px"><span style=3D"font-family:Courier New,mono=

+space">=E2=80=A2</span></div>

+</td>

+<td style=3D"padding-right:10px;font-family:Arial,Sans-serif;font-size:13px=

+;color:#222">

+<div style=3D"text-indent:-1px">

+<div>

+<div style=3D"margin:0 0 0.3em 0"><span itemprop=3D"attendee" itemscope=3D"=

+" itemtype=3D"http://schema.org/Person"><span itemprop=3D"name" class=3D"no=

+translate">homer@example.com</span>

+<meta itemprop=3D"email" content=3D"homer@example.com">

+</span></div>

+</div>

+</div>

+</td>

+</tr>

+</tbody>

+</table>

+</td>

+</tr>

+</tbody>

+</table>

+<div style=3D"float:right;font-weight:bold;font-size:13px"><a href=3D"https=

+://calendar.google.com/calendar/event?action=3DVIEW&amp;eid=3DNjVtMTdoc2Rvb=

+G1vdHYza3ZtcnRnNDBvbnQgbWFnbnVzLm1lbGluQGh1dC5maQ&amp;tok=3DMjEjYmVydGF0aGV=

+ib3RAZ21haWwuY29tZTg2NGFjYmNjYWE1MjVlZWJmY2UzYmRmMDAyNWU0MDkzNDAxZjRhZg&amp=

+;ctz=3DEurope%2FHelsinki&amp;hl=3Dsv&amp;es=3D0" style=3D"color:#20c;white-=

+space:nowrap" itemprop=3D"url">mer

+ information =C2=BB</a><br>

+</div>

+<div style=3D"padding-bottom:15px;font-family:Arial,Sans-serif;font-size:13=

+px;color:#222;white-space:pre-wrap!important;white-space:-moz-pre-wrap!impo=

+rtant;white-space:-pre-wrap!important;white-space:-o-pre-wrap!important;whi=

+te-space:pre;word-wrap:break-word">

+<span>This is a test. <b>Bold</b>. <i>Italic</i>. <br>

+<br>

+Will discuss address for email &lt;<a href=3D"mailto:foo@example.com" targe=

+t=3D"_blank">foo@example.com</a>&gt; and

+<a href=3D"https://www.google.com/url?q=3Dhttp%3A%2F%2Fexample.com%3Ffoo%3D=

+bar&amp;sa=3DD&amp;ust=3D1616836340813000&amp;usg=3DAOvVaw04gjO0O3Bf1tJs9vs=

+BMj3x" target=3D"_blank">

+http://example.com?foo=3Dbar</a>.</span>

+<meta itemprop=3D"description" content=3D"This is a test. Bold. Italic.&nbs=

+p;Will discuss address for email &lt;foo@example.com&gt; and http://example=

+.com?foo=3Dbar.">

+</div>

+</div>

+<p style=3D"color:#222;font-size:13px;margin:0"><span style=3D"color:#888">=

+Ska du delta (homer@example.com)?

+</span><wbr><strong><span itemprop=3D"potentialaction" itemscope=3D"" itemt=

+ype=3D"http://schema.org/RsvpAction">

+<meta itemprop=3D"attendance" content=3D"http://schema.org/RsvpAttendance/Y=

+es">

+<span itemprop=3D"handler" itemscope=3D"" itemtype=3D"http://schema.org/Htt=

+pActionHandler"><link itemprop=3D"method" href=3D"http://schema.org/HttpReq=

+uestMethod/GET"><a href=3D"https://calendar.google.com/calendar/event?actio=

+n=3DRESPOND&amp;eid=3DNjVtMTdoc2RvbG1vdHYza3ZtcnRnNDBvbnQgbWFnbnVzLm1lbGluQ=

+Gh1dC5maQ&amp;rst=3D1&amp;tok=3DMjEjYmVydGF0aGVib3RAZ21haWwuY29tZTg2NGFjYmN=

+jYWE1MjVlZWJmY2UzYmRmMDAyNWU0MDkzNDAxZjRhZg&amp;ctz=3DEurope%2FHelsinki&amp=

+;hl=3Dsv&amp;es=3D0" style=3D"color:#20c;white-space:nowrap" itemprop=3D"ur=

+l">Ja</a></span></span><span style=3D"margin:0 0.4em;font-weight:normal">

+ - </span><span itemprop=3D"potentialaction" itemscope=3D"" itemtype=3D"htt=

+p://schema.org/RsvpAction">

+<meta itemprop=3D"attendance" content=3D"http://schema.org/RsvpAttendance/M=

+aybe">

+<span itemprop=3D"handler" itemscope=3D"" itemtype=3D"http://schema.org/Htt=

+pActionHandler"><link itemprop=3D"method" href=3D"http://schema.org/HttpReq=

+uestMethod/GET"><a href=3D"https://calendar.google.com/calendar/event?actio=

+n=3DRESPOND&amp;eid=3DNjVtMTdoc2RvbG1vdHYza3ZtcnRnNDBvbnQgbWFnbnVzLm1lbGluQ=

+Gh1dC5maQ&amp;rst=3D3&amp;tok=3DMjEjYmVydGF0aGVib3RAZ21haWwuY29tZTg2NGFjYmN=

+jYWE1MjVlZWJmY2UzYmRmMDAyNWU0MDkzNDAxZjRhZg&amp;ctz=3DEurope%2FHelsinki&amp=

+;hl=3Dsv&amp;es=3D0" style=3D"color:#20c;white-space:nowrap" itemprop=3D"ur=

+l">Kanske</a></span></span><span style=3D"margin:0 0.4em;font-weight:normal=

+">

+ - </span><span itemprop=3D"potentialaction" itemscope=3D"" itemtype=3D"htt=

+p://schema.org/RsvpAction">

+<meta itemprop=3D"attendance" content=3D"http://schema.org/RsvpAttendance/N=

+o">

+<span itemprop=3D"handler" itemscope=3D"" itemtype=3D"http://schema.org/Htt=

+pActionHandler"><link itemprop=3D"method" href=3D"http://schema.org/HttpReq=

+uestMethod/GET"><a href=3D"https://calendar.google.com/calendar/event?actio=

+n=3DRESPOND&amp;eid=3DNjVtMTdoc2RvbG1vdHYza3ZtcnRnNDBvbnQgbWFnbnVzLm1lbGluQ=

+Gh1dC5maQ&amp;rst=3D2&amp;tok=3DMjEjYmVydGF0aGVib3RAZ21haWwuY29tZTg2NGFjYmN=

+jYWE1MjVlZWJmY2UzYmRmMDAyNWU0MDkzNDAxZjRhZg&amp;ctz=3DEurope%2FHelsinki&amp=

+;hl=3Dsv&amp;es=3D0" style=3D"color:#20c;white-space:nowrap" itemprop=3D"ur=

+l">Nej</a></span></span></strong>

+<wbr><a href=3D"https://calendar.google.com/calendar/event?action=3DVIEW&am=

+p;eid=3DNjVtMTdoc2RvbG1vdHYza3ZtcnRnNDBvbnQgbWFnbnVzLm1lbGluQGh1dC5maQ&amp;=

+tok=3DMjEjYmVydGF0aGVib3RAZ21haWwuY29tZTg2NGFjYmNjYWE1MjVlZWJmY2UzYmRmMDAyN=

+WU0MDkzNDAxZjRhZg&amp;ctz=3DEurope%2FHelsinki&amp;hl=3Dsv&amp;es=3D0" style=

+=3D"color:#20c;white-space:nowrap" itemprop=3D"url">fler

+ alternativ =C2=BB</a></p>

+</td>

+</tr>

+<tr>

+<td style=3D"background-color:#f6f6f6;color:#888;border-top:1px Solid #ccc;=

+font-family:Arial,Sans-serif;font-size:11px">

+<p>Inbjudan fr=C3=A5n <a href=3D"https://calendar.google.com/calendar/" tar=

+get=3D"_blank" style=3D"">

+Google Kalender</a></p>

+<p>Detta e-postmeddelande har skickats till kontot homer@example.com efte=

+rsom du =C3=A4r deltagare vid denna h=C3=A4ndelse.</p>

+<p>Om du inte vill f=C3=A5 uppdateringar om denna h=C3=A4ndelse i framtiden=

+ kan du tacka nej till denna h=C3=A4ndelse. Du kan =C3=A4ven registrera dig=

+ f=C3=B6r att f=C3=A5 ett Google-konto p=C3=A5 https://calendar.google.com/=

+calendar/ och kontrollera aviseringsinst=C3=A4llningarna f=C3=B6r hela kale=

+ndern.</p>

+<p>Om du vidarebefordrar den h=C3=A4r inbjudan kan det g=C3=B6ra det m=C3=

+=B6jligt f=C3=B6r alla mottagare att skicka ett svar till organisat=C3=B6re=

+n och l=C3=A4ggas till p=C3=A5 g=C3=A4stlistan, bjuda in andra oavsett dera=

+s egen inbjudningsstatus eller modifiera ditt OSA.

+<a href=3D"https://support.google.com/calendar/answer/37135#forwarding">L=

+=C3=A4s mer</a>.</p>

+</td>

+</tr>

+</tbody>

+</table>

+</div>

+</span></span>

+</body>

+</html>

+

+--0000000000008c6d6005be1c767c

+Content-Type: text/calendar; charset="UTF-8"; method=REQUEST

+Content-Transfer-Encoding: quoted-printable

+

+BEGIN:VCALENDAR

+PRODID:-//Google Inc//Google Calendar 70.9054//EN

+VERSION:2.0

+CALSCALE:GREGORIAN

+METHOD:REQUEST

+BEGIN:VEVENT

+DTSTART:20210322T093000Z

+DTEND:20210322T103000Z

+DTSTAMP:20210322T091220Z

+ORGANIZER;CN=3Dexample@gmail.com:mailto:example@gmail.com

+UID:65m17hsdolmotv3kvmrtg40ont@google.com

+ATTENDEE;CUTYPE=3DINDIVIDUAL;ROLE=3DREQ-PARTICIPANT;PARTSTAT=3DACCEPTED;RSV=

+P=3DTRUE

+ ;CN=3Dexample@gmail.com;X-NUM-GUESTS=3D0:mailto:example@gmail.com

+ATTENDEE;CUTYPE=3DINDIVIDUAL;ROLE=3DREQ-PARTICIPANT;PARTSTAT=3DNEEDS-ACTION=

+;RSVP=3D

+ TRUE;CN=3Dhomer@example.com;X-NUM-GUESTS=3D0:mailto:homer@example.com

+X-MICROSOFT-CDO-OWNERAPPTID:-410050292

+CREATED:20210322T091220Z

+DESCRIPTION:This is a test. <b>Bold</b>. <i>Italic</i>.&nbsp\;<br><br>Will=

+=20

+ discuss address for email &lt\;foo@example.com&gt\; and http://example.com=

+?

+ foo=3Dbar.\n\n-::~:~::~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:=

+~:~

+ :~:~:~:~:~:~:~:~::~:~::-\n=C3=84ndra inte det h=C3=A4r avsnittet i beskriv=

+ningen.\n\n

+ Den h=C3=A4r h=C3=A4ndelsen har ett videosamtal.\nG=C3=A5 med: https://mee=

+t.google.com/pyb

+ -ndcu-hhc\n\nVisa din h=C3=A4ndelse p=C3=A5 https://calendar.google.com/ca=

+lendar/even

+ t?action=3DVIEW&eid=3DNjVtMTdoc2RvbG1vdHYza3ZtcnRnNDBvbnQgbWFnbnVzLm1lbGlu=

+QGh1d

+ C5maQ&tok=3DMjEjYmVydGF0aGVib3RAZ21haWwuY29tZTg2NGFjYmNjYWE1MjVlZWJmY2UzYm=

+RmM

+ DAyNWU0MDkzNDAxZjRhZg&ctz=3DEurope%2FHelsinki&hl=3Dsv&es=3D1.\n-::~:~::~:~=

+:~:~:~:

+ ~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~:~::~:~::-

+LAST-MODIFIED:20210322T091220Z

+LOCATION:

+SEQUENCE:0

+STATUS:CONFIRMED

+SUMMARY:Meeeeet me HTML

+TRANSP:OPAQUE

+END:VEVENT

+END:VCALENDAR

+

+--0000000000008c6d6005be1c767c--

+

+--0000000000008c6d6205be1c767e

+Content-Type: application/ics; name="invite.ics"

+Content-Disposition: attachment; filename="invite.ics"

+Content-Transfer-Encoding: base64

+

+QkVHSU46VkNBTEVOREFSClBST0RJRDotLy9Hb29nbGUgSW5jLy9Hb29nbGUgQ2FsZW5kYXIgNzAu

+OTA1NC8vRU4KVkVSU0lPTjoyLjAKQ0FMU0NBTEU6R1JFR09SSUFOCk1FVEhPRDpSRVFVRVNUCkJF

+R0lOOlZFVkVOVApEVFNUQVJUOjIwMjEwMzIyVDA5MzAwMFoKRFRFTkQ6MjAyMTAzMjJUMTAzMDAw

+WgpEVFNUQU1QOjIwMjEwMzIyVDA5MTIyMFoKT1JHQU5JWkVSO0NOPWV4YW1wbGVAZ21haWwuY29t

+Om1haWx0bzpleGFtcGxlQGdtYWlsLmNvbQpVSUQ6NjVtMTdoc2RvbG1vdHYza3ZtcnRnNDBvbnRA

+Z29vZ2xlLmNvbQpBVFRFTkRFRTtDVVRZUEU9SU5ESVZJRFVBTDtST0xFPVJFUS1QQVJUSUNJUEFO

+VDtQQVJUU1RBVD1BQ0NFUFRFRDtSU1ZQPVRSVUUKIDtDTj1leGFtcGxlQGdtYWlsLmNvbTtYLU5V

+TS1HVUVTVFM9MDptYWlsdG86ZXhhbXBsZUBnbWFpbC5jb20KQVRURU5ERUU7Q1VUWVBFPUlORElW

+SURVQUw7Uk9MRT1SRVEtUEFSVElDSVBBTlQ7UEFSVFNUQVQ9TkVFRFMtQUNUSU9OO1JTVlA9CiBU

+UlVFO0NOPWhvbWVyQGV4YW1wbGUuY29tO1gtTlVNLUdVRVNUUz0wOm1haWx0bzpob21lckBleGFt

+cGxlLmNvbQpYLU1JQ1JPU09GVC1DRE8tT1dORVJBUFBUSUQ6LTQxMDA1MDI5MgpDUkVBVEVEOjIw

+MjEwMzIyVDA5MTIyMFoKREVTQ1JJUFRJT046VGhpcyBpcyBhIHRlc3QuIDxiPkJvbGQ8L2I+LiA8

+aT5JdGFsaWM8L2k+LiZuYnNwXDs8YnI+PGJyPldpbGwgCiBkaXNjdXNzIGFkZHJlc3MgZm9yIGVt

+YWlsICZsdFw7Zm9vQGV4YW1wbGUuY29tJmd0XDsgYW5kIGh0dHA6Ly9leGFtcGxlLmNvbT8KIGZv

+bz1iYXIuXG5cbi06On46fjo6fjp+On46fjp+On46fjp+On46fjp+On46fjp+On46fjp+On46fjp+

+On46fjp+On46fjp+On46fgogOn46fjp+On46fjp+On46fjo6fjp+OjotXG7DhG5kcmEgaW50ZSBk

+ZXQgaMOkciBhdnNuaXR0ZXQgaSBiZXNrcml2bmluZ2VuLlxuXG4KIERlbiBow6RyIGjDpG5kZWxz

+ZW4gaGFyIGV0dCB2aWRlb3NhbXRhbC5cbkfDpSBtZWQ6IGh0dHBzOi8vbWVldC5nb29nbGUuY29t

+L3B5YgogLW5kY3UtaGhjXG5cblZpc2EgZGluIGjDpG5kZWxzZSBww6UgaHR0cHM6Ly9jYWxlbmRh

+ci5nb29nbGUuY29tL2NhbGVuZGFyL2V2ZW4KIHQ/YWN0aW9uPVZJRVcmZWlkPU5qVnRNVGRvYzJS

+dmJHMXZkSFl6YTNadGNuUm5OREJ2Ym5RZ2JXRm5iblZ6TG0xbGJHbHVRR2gxZAogQzVtYVEmdG9r

+PU1qRWpZbVZ5ZEdGMGFHVmliM1JBWjIxaGFXd3VZMjl0WlRnMk5HRmpZbU5qWVdFMU1qVmxaV0pt

+WTJVelltUm1NCiBEQXlOV1UwTURrek5EQXhaalJoWmcmY3R6PUV1cm9wZSUyRkhlbHNpbmtpJmhs

+PXN2JmVzPTEuXG4tOjp+On46On46fjp+On46fjoKIH46fjp+On46fjp+On46fjp+On46fjp+On46

+fjp+On46fjp+On46fjp+On46fjp+On46fjp+On46fjp+On46On46fjo6LQpMQVNULU1PRElGSUVE

+OjIwMjEwMzIyVDA5MTIyMFoKTE9DQVRJT046ClNFUVVFTkNFOjAKU1RBVFVTOkNPTkZJUk1FRApT

+VU1NQVJZOk1lZWVlZXQgbWUgSFRNTApUUkFOU1A6T1BBUVVFCkVORDpWRVZFTlQKRU5EOlZDQUxF

+TkRBUgo=

+

+--0000000000008c6d6205be1c767e--

diff --git a/comm/calendar/test/browser/invitations/data/message-containing-event.eml b/comm/calendar/test/browser/invitations/data/message-containing-event.eml
new file mode 100644
index 0000000000..d27c2976db
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/message-containing-event.eml
@@ -0,0 +1,44 @@
+From: ExampleStore <noreply@example.com>
+Date: Wed, 24 Aug 2016 16:40:06 -0400
+Subject: ExampleStore - booking 01.09.2016 @ 09.25 - 09.50
+Content-Type: multipart/mixed;
+	boundary="_=aspNetEmail=_51bed191ceac49f7a22392ea84b6ef35"
+To: <foo@example.com>
+Message-ID: <df0f52ae-d3dc-4b89-bc3e-67fc4f6e8552@example.com>
+MIME-Version: 1.0
+
+--_=aspNetEmail=_51bed191ceac49f7a22392ea84b6ef35
+Content-Type: multipart/alternative;
+	boundary="_=ALT_=aspNetEmail=_51bed191ceac49f7a22392ea84b6ef35"
+
+--_=ALT_=aspNetEmail=_51bed191ceac49f7a22392ea84b6ef35
+Content-Type: text/plain; charset="UTF-8"
+
+Remember your booking @ 09.25
+
+--_=ALT_=aspNetEmail=_51bed191ceac49f7a22392ea84b6ef35
+Content-Type: text/html; charset="UTF-8"
+
+<html>
+<body>
+<p>You have a booking for 9.25</p>
+</body>
+</html>
+
+--_=ALT_=aspNetEmail=_51bed191ceac49f7a22392ea84b6ef35--
+
+--_=aspNetEmail=_51bed191ceac49f7a22392ea84b6ef35
+Content-Type: TeXt/CaLeNdAr; method=PUBLISH; charset=UTF-8
+Content-Transfer-Encoding: base64
+Content-Disposition: attachment; filename="booking.ics"
+
+QkVHSU46VkNBTEVOREFSDQpWRVJTSU9OOjIuMA0KTUVUSE9EOlBVQkxJU0gNClBST0RJRDpleGFt
+cGxlLmNvbQ0KQkVHSU46VkVWRU5UDQpEVFNUQVJUOjIwMTYwOTAxVDA2MjUwMFoNCkRURU5EOjIw
+MTYwOTAxVDA2NTAwMFoNCkRUU1RBTVA6MjAxNjA4MjRUMjA0MDAwWg0KVUlEOjIwMTYwODI0VDIw
+NDAwMFotNTY4ODYwMjgwQGV4YW1wbGUuY29tDQpTVU1NQVJZOkhhaXJjdXQNCk9SR0FOSVpFUjpt
+YWlsdG86c29tZW9uZUBleGFtcGxlLmNvbQ0KREVTQ1JJUFRJT046SGFpcmN1dCtzdHlsaW5nDQpM
+T0NBVElPTjpTb21ld2hlcmUNClRSQU5TUDpPUEFRVUUNClNFUVVFTkNFOjANCkNMQVNTOlBVQkxJ
+Qw0KQkVHSU46VkFMQVJNDQpUUklHR0VSOi1QVDYwTQ0KQUNUSU9OOkFVRElPDQpERVNDUklQVElP
+TjpSZW1pbmRlcg0KRU5EOlZBTEFSTQ0KRU5EOlZFVkVOVA0KRU5EOlZDQUxFTkRBUg==
+
+--_=aspNetEmail=_51bed191ceac49f7a22392ea84b6ef35--
diff --git a/comm/calendar/test/browser/invitations/data/message-non-invite.eml b/comm/calendar/test/browser/invitations/data/message-non-invite.eml
new file mode 100644
index 0000000000..cf391f445a
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/message-non-invite.eml
@@ -0,0 +1,115 @@
+Date: Sun, 28 Nov 2021 21:39:31 +0000
+From: Jane <noreply@example.com>
+To: <john.doe@example.com>
+Message-ID: <1074020157.32201638135571450.JavaMail.root@hki-example-prod-app-004>
+Subject: We're having a party - you're NOT invited
+Content-Type: multipart/mixed;
+	boundary="----=_Part_6440_2094089067.1638135571440"
+MIME-Version: 1.0
+
+------=_Part_6440_2094089067.1638135571440
+Content-Type: multipart/related;
+	boundary="----=_Part_6441_499243807.1638135571440"
+
+------=_Part_6441_499243807.1638135571440
+Content-Type: text/plain; charset="UTF-8"
+
+Hey, we're having a party! You're not invited ;)
+
+------=_Part_6441_499243807.1638135571440--
+
+------=_Part_6440_2094089067.1638135571440
+Content-Type: text/calendar; charset="utf-8"; name="event.ics"
+Content-Transfer-Encoding: quoted-printable
+Content-Disposition: attachment; filename="event.ics"
+
+BEGIN:VCALENDAR
+PRODID:-//EXAMPLE:COM//iCal4j 1.0.5.2//EN
+VERSION:2.0
+CALSCALE:GREGORIAN
+METHOD:PUBLISH
+BEGIN:VTIMEZONE
+TZID:Europe/Helsinki
+TZURL:http://tzurl.org/zoneinfo/Europe/Helsinki
+X-LIC-LOCATION:Europe/Helsinki
+BEGIN:DAYLIGHT
+TZOFFSETFROM:+0200
+TZOFFSETTO:+0300
+TZNAME:EEST
+DTSTART:19830327T030000
+RRULE:FREQ=3DYEARLY;BYMONTH=3D3;BYDAY=3D-1SU
+END:DAYLIGHT
+BEGIN:STANDARD
+TZOFFSETFROM:+0300
+TZOFFSETTO:+0200
+TZNAME:EET
+DTSTART:19961027T040000
+RRULE:FREQ=3DYEARLY;BYMONTH=3D10;BYDAY=3D-1SU
+END:STANDARD
+BEGIN:STANDARD
+TZOFFSETFROM:+013952
+TZOFFSETTO:+013952
+TZNAME:HMT
+DTSTART:18780531T000000
+RDATE:18780531T000000
+END:STANDARD
+BEGIN:STANDARD
+TZOFFSETFROM:+013952
+TZOFFSETTO:+0200
+TZNAME:EET
+DTSTART:19210501T000000
+RDATE:19210501T000000
+END:STANDARD
+BEGIN:DAYLIGHT
+TZOFFSETFROM:+0200
+TZOFFSETTO:+0300
+TZNAME:EEST
+DTSTART:19420403T000000
+RDATE:19420403T000000
+RDATE:19810329T020000
+RDATE:19820328T020000
+END:DAYLIGHT
+BEGIN:STANDARD
+TZOFFSETFROM:+0300
+TZOFFSETTO:+0200
+TZNAME:EET
+DTSTART:19421003T000000
+RDATE:19421003T000000
+RDATE:19810927T030000
+RDATE:19820926T030000
+RDATE:19830925T040000
+RDATE:19840930T040000
+RDATE:19850929T040000
+RDATE:19860928T040000
+RDATE:19870927T040000
+RDATE:19880925T040000
+RDATE:19890924T040000
+RDATE:19900930T040000
+RDATE:19910929T040000
+RDATE:19920927T040000
+RDATE:19930926T040000
+RDATE:19940925T040000
+RDATE:19950924T040000
+END:STANDARD
+BEGIN:STANDARD
+TZOFFSETFROM:+0200
+TZOFFSETTO:+0200
+TZNAME:EET
+DTSTART:19830101T000000
+RDATE:19830101T000000
+END:STANDARD
+END:VTIMEZONE
+BEGIN:VEVENT
+DTSTAMP:20211128T213931Z
+DTSTART;TZID=3DEurope/Helsinki:20211129T105500
+DTEND;TZID=3DEurope/Helsinki:20211129T110000
+SUMMARY:Party at John's house\, Helsinki
+ORGANIZER;CN=3DJANE:mailto:noreply@example.com
+UID:1e5fd4e6-bc52-439c-ac76-40da54f57c77@secure.example.com
+SEQUENCE:3
+STATUS:CONFIRMED
+LAST-MODIFIED:20211128T213931Z
+END:VEVENT
+END:VCALENDAR
+
+------=_Part_6440_2094089067.1638135571440--
diff --git a/comm/calendar/test/browser/invitations/data/outlook-test-invite.eml b/comm/calendar/test/browser/invitations/data/outlook-test-invite.eml
new file mode 100644
index 0000000000..de07a9b873
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/outlook-test-invite.eml
@@ -0,0 +1,102 @@
+From: Marge <marge@example.org>

+To: Homer <homer@example.org>

+Subject: Testaus

+Thread-Topic: Testaus

+Thread-Index: AdfdgAAehFDfsPyXTommZqRYgeMqiQAABo4Q

+Date: Fri, 19 Nov 2021 20:00:31 +0000

+Message-ID: <HE1P190MB0540579ABA18FCE320901B31E39C9@HE1P190MB0540.EURP190.PROD.OUTLOOK.COM>

+Accept-Language: en-US

+Content-Language: en-US

+Content-Type: multipart/alternative;

+	boundary="_000_HE1P190MB0540579ABA18FCE320901B31E39C9HE1P190MB0540EURP_"

+MIME-Version: 1.0

+

+--_000_HE1P190MB0540579ABA18FCE320901B31E39C9HE1P190MB0540EURP_

+Content-Type: text/plain; charset="iso-8859-1"

+Content-Transfer-Encoding: quoted-printable

+

+

+

+--_000_HE1P190MB0540579ABA18FCE320901B31E39C9HE1P190MB0540EURP_

+Content-Type: text/html; charset="iso-8859-1"

+Content-Transfer-Encoding: quoted-printable

+

+<html xmlns:v=3D"urn:schemas-microsoft-com:vml" xmlns:o=3D"urn:schemas-micr=

+osoft-com:office:office" xmlns:w=3D"urn:schemas-microsoft-com:office:word" =

+xmlns:m=3D"http://schemas.microsoft.com/office/2004/12/omml" xmlns=3D"http:=

+//www.w3.org/TR/REC-html40"><head>

+<meta http-equiv=3D"Content-Type" content=3D"text/html; charset=3Diso-8859-=

+1">

+<meta name=3D"Generator" content=3D"Microsoft Word 15 (filtered medium)">

+<style><!--

+/* Font Definitions */

+@font-face

+	{font-family:"Cambria Math";

+	panose-1:2 4 5 3 5 4 6 3 2 4;}

+@font-face

+	{font-family:Calibri;

+	panose-1:2 15 5 2 2 2 4 3 2 4;}

+/* Style Definitions */

+p.MsoNormal, li.MsoNormal, div.MsoNormal

+	{margin:0cm;

+	font-size:11.0pt;

+	font-family:"Calibri",sans-serif;

+	mso-fareast-language:EN-US;}

+span.EmailStyle18

+	{mso-style-type:personal-compose;

+	font-family:"Calibri",sans-serif;

+	color:windowtext;}

+.MsoChpDefault

+	{mso-style-type:export-only;

+	font-size:10.0pt;}

+@page WordSection1

+	{size:612.0pt 792.0pt;

+	margin:70.85pt 2.0cm 70.85pt 2.0cm;}

+div.WordSection1

+	{page:WordSection1;}

+--></style><!--[if gte mso 9]><xml>

+<o:shapedefaults v:ext=3D"edit" spidmax=3D"1026" />

+</xml><![endif]--><!--[if gte mso 9]><xml>

+<o:shapelayout v:ext=3D"edit">

+<o:idmap v:ext=3D"edit" data=3D"1" />

+</o:shapelayout></xml><![endif]-->

+</head>

+<body lang=3D"FI" link=3D"#0563C1" vlink=3D"#954F72" style=3D"word-wrap:bre=

+ak-word">

+<div class=3D"WordSection1">

+<p class=3D"MsoNormal"><o:p>&nbsp;</o:p></p>

+</div>

+</body>

+</html>

+

+--_000_HE1P190MB0540579ABA18FCE320901B31E39C9HE1P190MB0540EURP_

+Content-Type: text/calendar; charset="utf-8"; method=REQUEST

+Content-Transfer-Encoding: base64

+

+QkVHSU46VkNBTEVOREFSCk1FVEhPRDpSRVFVRVNUClBST0RJRDpNaWNyb3NvZnQgRXhjaGFuZ2Ug

+U2VydmVyIDIwMTAKVkVSU0lPTjoyLjAKQkVHSU46VlRJTUVaT05FClRaSUQ6RkxFIFN0YW5kYXJk

+IFRpbWUKQkVHSU46U1RBTkRBUkQKRFRTVEFSVDoxNjAxMDEwMVQwNDAwMDAKVFpPRkZTRVRGUk9N

+OiswMzAwClRaT0ZGU0VUVE86KzAyMDAKUlJVTEU6RlJFUT1ZRUFSTFk7SU5URVJWQUw9MTtCWURB

+WT0tMVNVO0JZTU9OVEg9MTAKRU5EOlNUQU5EQVJECkJFR0lOOkRBWUxJR0hUCkRUU1RBUlQ6MTYw

+MTAxMDFUMDMwMDAwClRaT0ZGU0VURlJPTTorMDIwMApUWk9GRlNFVFRPOiswMzAwClJSVUxFOkZS

+RVE9WUVBUkxZO0lOVEVSVkFMPTE7QllEQVk9LTFTVTtCWU1PTlRIPTMKRU5EOkRBWUxJR0hUCkVO

+RDpWVElNRVpPTkUKQkVHSU46VkVWRU5UCk9SR0FOSVpFUjtDTj1NYXJnZTptYWlsdG86bWFyZ2VA

+ZXhhbXBsZS5vcmcKQVRURU5ERUU7Uk9MRT1SRVEtUEFSVElDSVBBTlQ7UEFSVFNUQVQ9TkVFRFMt

+QUNUSU9OO1JTVlA9VFJVRTtDTj1Ib20KIGVyOm1haWx0bzpob21lckBleGFtcGxlLm9yZwpERVND

+UklQVElPTjtMQU5HVUFHRT1lbi1VUzpcbgpVSUQ6MDMwMDAwMDA4MjAwRTAwMDc0QzVCNzEwMUE4

+MkUwMDgwMDAwMDAwMDYwQjYwOEQwOTBEREQ3MDEwMDAwMDAwMDAwMDAwMDAKIDAxMDAwMDAwMDRC

+RTBDRkZBNTRCQ0Y2NEU5NTZFMzQxNDMzNjJDM0MwClNVTU1BUlk7TEFOR1VBR0U9ZW4tVVM6VGVz

+dGF1cwpEVFNUQVJUO1RaSUQ9RkxFIFN0YW5kYXJkIFRpbWU6MjAyMTExMjdUMDkwMDAwCkRURU5E

+O1RaSUQ9RkxFIFN0YW5kYXJkIFRpbWU6MjAyMTExMjdUMDkzMDAwCkNMQVNTOlBVQkxJQwpQUklP

+UklUWTo1CkRUU1RBTVA6MjAyMTExMTlUMjAwMDI5WgpUUkFOU1A6T1BBUVVFClNUQVRVUzpDT05G

+SVJNRUQKU0VRVUVOQ0U6MApMT0NBVElPTjtMQU5HVUFHRT1lbi1VUzoKWC1NSUNST1NPRlQtQ0RP

+LUFQUFQtU0VRVUVOQ0U6MApYLU1JQ1JPU09GVC1DRE8tT1dORVJBUFBUSUQ6LTcyMDEyODAyNwpY

+LU1JQ1JPU09GVC1DRE8tQlVTWVNUQVRVUzpURU5UQVRJVkUKWC1NSUNST1NPRlQtQ0RPLUlOVEVO

+REVEU1RBVFVTOkJVU1kKWC1NSUNST1NPRlQtQ0RPLUFMTERBWUVWRU5UOkZBTFNFClgtTUlDUk9T

+T0ZULUNETy1JTVBPUlRBTkNFOjEKWC1NSUNST1NPRlQtQ0RPLUlOU1RUWVBFOjAKWC1NSUNST1NP

+RlQtRE9OT1RGT1JXQVJETUVFVElORzpGQUxTRQpYLU1JQ1JPU09GVC1ESVNBTExPVy1DT1VOVEVS

+OkZBTFNFClgtTUlDUk9TT0ZULUxPQ0FUSU9OUzpbXQpCRUdJTjpWQUxBUk0KREVTQ1JJUFRJT046

+UkVNSU5ERVIKVFJJR0dFUjtSRUxBVEVEPVNUQVJUOi1QVDE1TQpBQ1RJT046RElTUExBWQpFTkQ6

+VkFMQVJNCkVORDpWRVZFTlQKRU5EOlZDQUxFTkRBUgo=

+

+--_000_HE1P190MB0540579ABA18FCE320901B31E39C9HE1P190MB0540EURP_--

diff --git a/comm/calendar/test/browser/invitations/data/repeat-event.eml b/comm/calendar/test/browser/invitations/data/repeat-event.eml
new file mode 100644
index 0000000000..9247e6575b
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/repeat-event.eml
@@ -0,0 +1,49 @@
+MIME-Version: 1.0

+Date: Mon, 28 Mar 2022 17:49:35 +0000

+Subject: Invitation: Repeat Event @ Daily from 2pm to 3pm 3 times (AST) (receiver@example.com)

+From: sender@example.com

+To: receiver@example.com

+Content-Type: multipart/mixed; boundary="00000000000080f3db05db4aef5b"

+

+--00000000000080f3db05db4aef5b

+Content-Type: multipart/alternative; boundary="00000000000080f3da05db4aef59"

+

+--00000000000080f3da05db4aef59

+Content-Type: text/calendar; charset="UTF-8"; method=REQUEST

+Content-Transfer-Encoding: 7bit

+

+BEGIN:VCALENDAR

+METHOD:REQUEST

+BEGIN:VEVENT

+DTSTART:20220316T110000Z

+DTEND:20220316T113000Z

+RRULE:FREQ=DAILY;WKST=SU;COUNT=3;INTERVAL=1

+DTSTAMP:20220316T191602Z

+UID:02e79b96

+ORGANIZER;CN=Sender;

+ EMAIL=sender@example.com:mailto:sender@example.com

+ATTENDEE;CN=Sender;

+ EMAIL=sender@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=ACCEPTED;RSVP=FALSE:mailto:sender@example.com

+ATTENDEE;CN=Receiver;EMAIL=receiver@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:receiver@example.com

+ATTENDEE;CN=Other;EMAIL=other@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:other@example.com

+CREATED:20220328T174934Z

+LAST-MODIFIED:20220328T174934Z

+LOCATION:Somewhere

+SEQUENCE:0

+STATUS:CONFIRMED

+SUMMARY:Repeat Event

+DESCRIPTION:An event invitation.

+TRANSP:OPAQUE

+BEGIN:VALARM

+ACTION:DISPLAY

+TRIGGER:-P1D

+DESCRIPTION:This is an event reminder

+END:VALARM

+END:VEVENT

+END:VCALENDAR

+

+--00000000000080f3da05db4aef59--

+--00000000000080f3db05db4aef5b--

diff --git a/comm/calendar/test/browser/invitations/data/repeat-update-major.eml b/comm/calendar/test/browser/invitations/data/repeat-update-major.eml
new file mode 100644
index 0000000000..61fe9f5022
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/repeat-update-major.eml
@@ -0,0 +1,49 @@
+MIME-Version: 1.0

+Date: Mon, 28 Mar 2022 17:49:35 +0000

+Subject: Repeat Update Major

+From: sender@example.com

+To: receiver@example.com

+Content-Type: multipart/mixed; boundary="00000000000080f3db05db4aef5b"

+

+--00000000000080f3db05db4aef5b

+Content-Type: multipart/alternative; boundary="00000000000080f3da05db4aef59"

+

+--00000000000080f3da05db4aef59

+Content-Type: text/calendar; charset="UTF-8"; method=REQUEST

+Content-Transfer-Encoding: 7bit

+

+BEGIN:VCALENDAR

+METHOD:REQUEST

+BEGIN:VEVENT

+DTSTART:20220316T050000Z

+DTEND:20220316T053000Z

+RRULE:FREQ=DAILY;WKST=SU;COUNT=3;INTERVAL=1

+DTSTAMP:20220316T191602Z

+UID:02e79b96

+ORGANIZER;CN=Sender;

+ EMAIL=sender@example.com:mailto:sender@example.com

+ATTENDEE;CN=Sender;

+ EMAIL=sender@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=ACCEPTED;RSVP=FALSE:mailto:sender@example.com

+ATTENDEE;CN=Receiver;EMAIL=receiver@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:receiver@example.com

+ATTENDEE;CN=Other;EMAIL=other@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:other@example.com

+CREATED:20220328T174934Z

+LAST-MODIFIED:20220328T174934Z

+LOCATION:Somewhere

+SEQUENCE:2

+STATUS:CONFIRMED

+SUMMARY:Repeat Event

+DESCRIPTION:An event invitation.

+TRANSP:OPAQUE

+BEGIN:VALARM

+ACTION:DISPLAY

+TRIGGER:-P1D

+DESCRIPTION:This is an event reminder

+END:VALARM

+END:VEVENT

+END:VCALENDAR

+

+--00000000000080f3da05db4aef59--

+--00000000000080f3db05db4aef5b--

diff --git a/comm/calendar/test/browser/invitations/data/repeat-update-minor.eml b/comm/calendar/test/browser/invitations/data/repeat-update-minor.eml
new file mode 100644
index 0000000000..a6ad357553
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/repeat-update-minor.eml
@@ -0,0 +1,49 @@
+MIME-Version: 1.0

+Date: Mon, 28 Mar 2022 17:49:35 +0000

+Subject: Invitation: Repeat Update Minor

+From: sender@example.com

+To: receiver@example.com

+Content-Type: multipart/mixed; boundary="00000000000080f3db05db4aef5b"

+

+--00000000000080f3db05db4aef5b

+Content-Type: multipart/alternative; boundary="00000000000080f3da05db4aef59"

+

+--00000000000080f3da05db4aef59

+Content-Type: text/calendar; charset="UTF-8"; method=REQUEST

+Content-Transfer-Encoding: 7bit

+

+BEGIN:VCALENDAR

+METHOD:REQUEST

+BEGIN:VEVENT

+DTSTART:20220316T110000Z

+DTEND:20220316T113000Z

+RRULE:FREQ=DAILY;WKST=SU;COUNT=3;INTERVAL=1

+DTSTAMP:20220318T191602Z

+UID:02e79b96

+ORGANIZER;CN=Sender;

+ EMAIL=sender@example.com:mailto:sender@example.com

+ATTENDEE;CN=Sender;

+ EMAIL=sender@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=ACCEPTED;RSVP=FALSE:mailto:sender@example.com

+ATTENDEE;CN=Receiver;EMAIL=receiver@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:receiver@example.com

+ATTENDEE;CN=Other;EMAIL=other@example.com;CUTYPE=INDIVIDUAL;

+ PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:other@example.com

+CREATED:20220328T174934Z

+LAST-MODIFIED:20220328T174934Z

+LOCATION:Updated location

+SEQUENCE:0

+STATUS:CONFIRMED

+SUMMARY:Updated Event

+DESCRIPTION:Updated description.

+TRANSP:OPAQUE

+BEGIN:VALARM

+ACTION:DISPLAY

+TRIGGER:-P1D

+DESCRIPTION:Updated description.

+END:VALARM

+END:VEVENT

+END:VCALENDAR

+

+--00000000000080f3da05db4aef59--

+--00000000000080f3db05db4aef5b--

diff --git a/comm/calendar/test/browser/invitations/data/single-event.eml b/comm/calendar/test/browser/invitations/data/single-event.eml
new file mode 100644
index 0000000000..14418c2c79
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/single-event.eml
@@ -0,0 +1,78 @@
+MIME-Version: 1.0
+Content-Transfer-Encoding: binary
+Content-Type: multipart/mixed; boundary="_----------=_1647458162153312762582"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+To: receiver@example.com
+Subject: Invitation: Single Event @ Wed, Mar 16 2022 11:00 AST
+From: Sender <sender@example.com>
+
+This is a multi-part message in MIME format.
+
+--_----------=_1647458162153312762582
+MIME-Version: 1.0
+Content-Transfer-Encoding: binary
+Content-Type: multipart/alternative; boundary="_----------=_1647458162153312762583"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+This is a multi-part message in MIME format.
+
+--_----------=_1647458162153312762583
+MIME-Version: 1.0
+Content-Disposition: inline
+Content-Length: 227
+Content-Transfer-Encoding: binary
+Content-Type: text/plain; charset="utf-8"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+Single Event
+
+When:
+    Wed, Mar 16 2022
+    11:00 - 12:00 AST
+Where:
+    Somewhere
+
+--_----------=_1647458162153312762583
+MIME-Version: 1.0
+Content-Disposition: inline
+Content-Transfer-Encoding: quoted-printable
+Content-Type: text/calendar; charset="utf-8"; method="REQUEST"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+BEGIN:VCALENDAR
+VERSION:2.0
+METHOD:REQUEST
+CALSCALE:GREGORIAN
+BEGIN:VEVENT
+UID:02e79b96
+SEQUENCE:0
+DTSTAMP:20220316T191602Z
+CREATED:20220316T191532Z
+DTSTART:20220316T110000Z
+DTEND:20220316T113000Z
+DURATION:PT1H
+PRIORITY:0
+SUMMARY:Single Event
+DESCRIPTION:An event invitation.
+LOCATION:Somewhere
+STATUS:CONFIRMED
+TRANSP:OPAQUE
+CLASS:PUBLIC
+ORGANIZER;CN=3DSender;
+ EMAIL=3Dsender@example.com:mailto:sender@example.com
+ATTENDEE;CN=3DSender;
+ EMAIL=3Dsender@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DACCEPTED;RSVP=3DFALSE:mailto:sender@example.com
+ATTENDEE;CN=Receiver;EMAIL=3Dreceiver@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DNEEDS-ACTION;RSVP=3DTRUE:mailto:receiver@example.com
+ATTENDEE;CN=Other;EMAIL=other@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DNEEDS-ACTION;RSVP=3DTRUE:mailto:other@example.com
+BEGIN:VALARM
+ACTION:DISPLAY
+TRIGGER:-P1D
+DESCRIPTION:This is an event reminder
+END:VALARM
+END:VEVENT
+END:VCALENDAR
+
+--_----------=_1647458162153312762583--
diff --git a/comm/calendar/test/browser/invitations/data/teams-meeting-invite.eml b/comm/calendar/test/browser/invitations/data/teams-meeting-invite.eml
new file mode 100644
index 0000000000..777486ec87
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/teams-meeting-invite.eml
@@ -0,0 +1,167 @@
+From: Marge <marge@example.com>

+To: bart@example.com, homer@example.com

+Subject: Teams meeting

+Thread-Topic: Teams meeting

+Thread-Index: AdbIy2RnFnEYrGmq80aB3RiaEcOS6w==

+Date: Wed, 2 Dec 2020 16:52:34 +0000

+Message-ID: <HE1PR0802MB228346BE1576FEAB8A7F32328EF30@HE1PR0802MB2283.eurprd08.prod.outlook.com>

+Accept-Language: fi-FI, en-US

+Content-Language: en-US

+X-MS-Has-Attach:

+X-MS-TNEF-Correlator:

+Content-Type: multipart/alternative;

+	boundary="_000_HE1PR0802MB228346BE1576FEAB8A7F32328EF30HE1PR0802MB2283_"

+X-Spam-Flag: No

+Return-Path: marge@example.com

+MIME-Version: 1.0

+

+--_000_HE1PR0802MB228346BE1576FEAB8A7F32328EF30HE1PR0802MB2283_

+Content-Type: text/plain; charset="iso-8859-1"

+Content-Transfer-Encoding: quoted-printable

+

+

+

+

+___________________________________________________________________________=

+_____

+Microsoft Teams -kokous

+Liity tietokoneella tai mobiilisovelluksella

+Liity kokoukseen napsauttamalla t=E4t=E4<https://teams.microsoft.com/l/meet=

+up-join/19%3ameeting_MHU5NmI5ZGAtOWZmOC00Y2ZmLWJlOTItNjUxNjA5YjUyYTYy%40thr=

+ead.v2/0?context=3D%7b%33Tid%22%3a%222fd0c1c5-28e1-40c4-9f0d-a0363ca80a3c%2=

+2%2c%22Oid%22%3a%2214464d09-ceb8-458c-a61c-717f1e5c66c5%22%7d>

+Lis=E4tietoja<https://aka.ms/JoinTeamsMeeting> | Kokousasetukset<https://te=

+ams.microsoft.com/meetingOptions/?organizerId=3D14464d09-ceb8-458c-a61c-717=

+f1e5c66c5&tenantId=3D2fd0c1c5-28e1-40c4-9f0d-a0363ca80a3c&threadId=3D19_mee=

+ting_MHU5NmI5ZGAtOWZmOC00Y2ZmLWJlOTItNjUxNjA5YjUyYTYy@thread.v2&messageId=

+=3D0&language=3Dfi-FI>

+___________________________________________________________________________=

+_____

+

+--_000_HE1PR0802MB228346BE1576FEAB8A7F32328EF30HE1PR0802MB2283_

+Content-Type: text/html; charset="iso-8859-1"

+Content-Transfer-Encoding: quoted-printable

+

+<html>

+<head>

+<meta http-equiv=3D"Content-Type" content=3D"text/html; charset=3Diso-8859-=

+1">

+</head>

+<body>

+<div><br>

+<br>

+<br>

+<div style=3D"width:100%;height: 20px;"><span style=3D"white-space:nowrap;c=

+olor:#5F5F5F;opacity:.36;">________________________________________________=

+________________________________</span>

+</div>

+<div class=3D"me-email-text" style=3D"color:#252424;font-family:'Segoe UI',=

+'Helvetica Neue',Helvetica,Arial,sans-serif;">

+<div style=3D"margin-top: 24px; margin-bottom: 20px;"><span style=3D"font-s=

+ize: 24px; color:#252424">Microsoft Teams -kokous</span>

+</div>

+<div style=3D"margin-bottom: 20px;">

+<div style=3D"margin-top: 0px; margin-bottom: 0px; font-weight: bold"><span=

+ style=3D"font-size: 14px; color:#252424">Liity tietokoneella tai mobiiliso=

+velluksella</span>

+</div>

+<a class=3D"me-email-headline" style=3D"font-size: 14px;font-family:'Segoe =

+UI Semibold','Segoe UI','Helvetica Neue',Helvetica,Arial,sans-serif;text-de=

+coration: underline;color: #6264a7;" href=3D"https://teams.microsoft.com/l/=

+meetup-join/19%3ameeting_MHU5NmI5ZGAtOWZmOC00Y2ZmLWJlOTItNjUxNjA5YjUyYTYy%4=

+0thread.v2/0?context=3D%7b%33Tid%22%3a%222fd0c1c5-28e1-40c4-9f0d-a0363ca80a=

+3c%22%2c%22Oid%22%3a%2214464d09-ceb8-458c-a61c-717f1e5c66c5%22%7d" target=

+=3D"_blank" rel=3D"noreferrer noopener">Liity

+ kokoukseen napsauttamalla t=E4t=E4</a> </div>

+<div style=3D"margin-bottom: 24px;margin-top: 20px;"><a class=3D"me-email-l=

+ink" style=3D"font-size: 14px;text-decoration: underline;color: #6264a7;fon=

+t-family:'Segoe UI','Helvetica Neue',Helvetica,Arial,sans-serif;" target=3D=

+"_blank" href=3D"https://aka.ms/JoinTeamsMeeting" rel=3D"noreferrer noopene=

+r">Lis=E4tietoja</a>

+ | <a class=3D"me-email-link" style=3D"font-size: 14px;text-decoration: und=

+erline;color: #6264a7;font-family:'Segoe UI','Helvetica Neue',Helvetica,Ari=

+al,sans-serif;" target=3D"_blank" href=3D"https://teams.microsoft.com/meeti=

+ngOptions/?organizerId=3D14464d09-ceb8-458c-a61c-717f1e5c66c5&amp;tenantId=

+=3D2fd0c1c5-28e1-40c4-9f0d-a0363ca80a3c&amp;threadId=3D19_meeting_MGU5NmI2Z=

+GYtOWZmOC00Y2ZmLWJlOTItNjUxNjA5YjUyYTYy@thread.v2&amp;messageId=3D0&amp;lan=

+guage=3Dfi-FI" rel=3D"noreferrer noopener">

+Kokousasetukset</a> </div>

+</div>

+<div style=3D"font-size: 14px; margin-bottom: 4px;font-family:'Segoe UI','H=

+elvetica Neue',Helvetica,Arial,sans-serif;">

+</div>

+<div style=3D"font-size: 12px;"></div>

+<div style=3D"width:100%;height: 20px;"><span style=3D"white-space:nowrap;c=

+olor:#5F5F5F;opacity:.36;">________________________________________________=

+________________________________</span>

+</div>

+</div>

+</body>

+</html>

+

+--_000_HE1PR0802MB228346BE1576FEAB8A7F32328EF30HE1PR0802MB2283_

+Content-Type: text/calendar; charset="utf-8"; method=REQUEST

+Content-Transfer-Encoding: base64

+

+QkVHSU46VkNBTEVOREFSCk1FVEhPRDpSRVFVRVNUClBST0RJRDpNaWNyb3NvZnQgRXhjaGFuZ2Ug

+U2VydmVyIDIwMTAKVkVSU0lPTjoyLjAKQkVHSU46VlRJTUVaT05FClRaSUQ6RkxFIFN0YW5kYXJk

+IFRpbWUKQkVHSU46U1RBTkRBUkQKRFRTVEFSVDoxNjAxMDEwMVQwNDAwMDAKVFpPRkZTRVRGUk9N

+OiswMzAwClRaT0ZGU0VUVE86KzAyMDAKUlJVTEU6RlJFUT1ZRUFSTFk7SU5URVJWQUw9MTtCWURB

+WT0tMVNVO0JZTU9OVEg9MTAKRU5EOlNUQU5EQVJECkJFR0lOOkRBWUxJR0hUCkRUU1RBUlQ6MTYw

+MTAxMDFUMDMwMDAwClRaT0ZGU0VURlJPTTorMDIwMApUWk9GRlNFVFRPOiswMzAwClJSVUxFOkZS

+RVE9WUVBUkxZO0lOVEVSVkFMPTE7QllEQVk9LTFTVTtCWU1PTlRIPTMKRU5EOkRBWUxJR0hUCkVO

+RDpWVElNRVpPTkUKQkVHSU46VkVWRU5UCk9SR0FOSVpFUjtDTj1NYXJnZTptYWlsdG86bWFyZ2VA

+ZXhhbXBsZS5jb20KQVRURU5ERUU7Uk9MRT1SRVEtUEFSVElDSVBBTlQ7UEFSVFNUQVQ9TkVFRFMt

+QUNUSU9OO1JTVlA9VFJVRTtDTj1iYXJ0QGUKIGV4YW1wbGUuY29tOm1haWx0bzpiYXJ0QGV4YW1w

+bGUuY29tCkFUVEVOREVFO1JPTEU9UkVRLVBBUlRJQ0lQQU5UO1BBUlRTVEFUPU5FRURTLUFDVElP

+TjtSU1ZQPVRSVUU7Q049aG9tZXJAZXgKIGFtcGxlLmNvbTptYWlsdG86aG9tZXJAZXhhbXBsZS5j

+b20KCkRFU0NSSVBUSU9OO0xBTkdVQUdFPWVuLVVTOlxuXG5cbl9fX19fX19fX19fX19fX19fX19f

+X19fX19fX19fX19fX19fX19fX19fXwogX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f

+X19fX19cbk1pY3Jvc29mdCBUZWFtcyAta29rb3VzXG5MaWl0eSB0aWUKIHRva29uZWVsbGEgdGFp

+IG1vYmlpbGlzb3ZlbGx1a3NlbGxhXG5MaWl0eSBrb2tvdWtzZWVuIG5hcHNhdXR0YW1hbGxhIHTD

+pHQKIMOkPGh0dHBzOi8vdGVhbXMubWljcm9zb2Z0LmNvbS9sL21lZXR1cC1qb2luLzE5JTNhbWVl

+dGluZ19NR1U1Tm1JMlpHWXRPV1ptCiBPQzAwWTJabUxXSmxPVEl0TmpVeE5qQTVZalV5WVRZeSU0

+MHRocmVhZC52Mi8wP2NvbnRleHQ9JTdiJTIyVGlkJTIyJTNhJTIyMgogZmQwYzFjNS0yOGUxLTQw

+YzQtOWYwZC1hMDM2M2NhODBhM2MlMjIlMmMlMjJPaWQlMjIlM2ElMjIxNDQ2NGQwOS1jZWI4LTQ1

+OGMKIC1hNjFjLTcxN2YxZTVjNjZjNSUyMiU3ZD5cbkxpc8OkdGlldG9qYTxodHRwczovL2FrYS5t

+cy9Kb2luVGVhbXNNZWV0aW5nPiB8CiAgS29rb3VzYXNldHVrc2V0PGh0dHBzOi8vdGVhbXMubWlj

+cm9zb2Z0LmNvbS9tZWV0aW5nT3B0aW9ucy8/b3JnYW5pemVySWQ9MQogNDQ2NGQwOS1jZWI4LTQ1

+OGMtYTYxYy03MTdmMWU1YzY2YzUmdGVuYW50SWQ9MmZkMGMxYzUtMjhlMS00MGM0LTlmMGQtYTAz

+NjMKIGNhODBhM2MmdGhyZWFkSWQ9MTlfbWVldGluZ19NR1U1Tm1JMlpHWXRPV1ptT0MwMFkyWm1M

+V0psT1RJdE5qVXhOakE1WWpVeVlUCiBZeUB0aHJlYWQudjImbWVzc2FnZUlkPTAmbGFuZ3VhZ2U9

+ZmktRkk+XG5fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwogX19fX19fX19fX19fX19f

+X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXG4KVUlEOjA1NjAwMDAwODIwMEUwMDA3

+NEM1QjcxMDFBODJFMDA4MDAwMDAwMDAxQUY4NEM2NENCQzhENjAxMDAwMDAwMDAwMDAwMDAwCiAw

+MTAwMDAwMDA0MDNCNUFDMTBBMEVCNDQ0QTk0N0QyQjQ5OUE0Qjk4QwpTVU1NQVJZO0xBTkdVQUdF

+PWVuLVVTOlRlYW1zIG1lZXRpbmcKRFRTVEFSVDtUWklEPUZMRSBTdGFuZGFyZCBUaW1lOjIwMjAx

+MjAyVDE5MDAwMApEVEVORDtUWklEPUZMRSBTdGFuZGFyZCBUaW1lOjIwMjAxMjAyVDIxMDAwMApD

+TEFTUzpQVUJMSUMKUFJJT1JJVFk6NQpEVFNUQU1QOjIwMjAxMjAyVDE2NTEzNFoKVFJBTlNQOk9Q

+QVFVRQpTVEFUVVM6Q09ORklSTUVEClNFUVVFTkNFOjAKTE9DQVRJT047TEFOR1VBR0U9ZW4tVVM6

+ClgtTUlDUk9TT0ZULUNETy1BUFBULVNFUVVFTkNFOjAKWC1NSUNST1NPRlQtQ0RPLU9XTkVSQVBQ

+VElEOjIxMTg5MTUzNTQKWC1NSUNST1NPRlQtQ0RPLUJVU1lTVEFUVVM6VEVOVEFUSVZFClgtTUlD

+Uk9TT0ZULUNETy1JTlRFTkRFRFNUQVRVUzpCVVNZClgtTUlDUk9TT0ZULUNETy1BTExEQVlFVkVO

+VDpGQUxTRQpYLU1JQ1JPU09GVC1DRE8tSU1QT1JUQU5DRToxClgtTUlDUk9TT0ZULUNETy1JTlNU

+VFlQRTowClgtTUlDUk9TT0ZULVNLWVBFVEVBTVNNRUVUSU5HVVJMOmh0dHBzOi8vdGVhbXMubWlj

+cm9zb2Z0LmNvbS9sL21lZXR1cC1qb2luLwogMTklM2FtZWV0aW5nX01HVTVObUkyWkdZdE9XWm1P

+QzAwWTJabUxXSmxPVEl0TmpVeE5qQTVZalV5WVRZeSU0MHRocmVhZC52Mi8KIDA/Y29udGV4dD0l

+N2IlMjJUaWQlMjIlM2ElMjIyZmQwYzFjNS0xOGUxLTQwYzQtOWYwZC1hMDM2M2NhODBhM2MlMjIl

+MmMlMjJPCiBpZCUyMiUzYSUyMjE0NDY0ZDA5LWNlYjgtNDU4Yy1hNjFjLTcxN2YxZTVjNjZjNSUy

+MiU3ZApYLU1JQ1JPU09GVC1TQ0hFRFVMSU5HU0VSVklDRVVQREFURVVSTDpodHRwczovL3NjaGVk

+dWxlci50ZWFtcy5taWNyb3NvZnQuY28KIG0vdGVhbXMvMmZkMGMxYzUtMjhlMS00MGM0LTlmMGQt

+YWIzNjNjYTgwYTNjLzE0NDY0ZDA5LWNlYjgtNDU4Yy1hNjFjLTcxN2YxCiBlNWM2NmM1LzE5X21l

+ZXRpbmdfTUdVNU5tSTJaR1l0T1dabU9DMDBZMlptTFdKbE9USXROalV4TmpBNVlqVXlZVFl5QHRo

+cmVhZAogLnYyLzAKWC1NSUNST1NPRlQtU0tZUEVURUFNU1BST1BFUlRJRVM6eyJjaWQiOiIxOTpt

+ZWV0aW5nX01HVTVObUkyWkdZdE9XWm1PQzAwWTJaCiBtTFdKbE9USXROalV4TmpBNVlqVXlZVFl5

+QHRocmVhZC52MiJcLCJyaWQiOjBcLCJtaWQiOjBcLCJ1aWQiOm51bGxcLCJwcml2YQogdGUiOnRy

+dWVcLCJ0eXBlIjowfQpYLU1JQ1JPU09GVC1PTkxJTkVNRUVUSU5HQ09ORkxJTks6Y29uZjpzaXA6

+bWFyZ2VAZXhhbXBsZS5jb21cO2dydXVcO29wCiBhcXVlPWFwcDpjb25mOmZvY3VzOmlkOnRlYW1z

+OjI6MCExOTptZWV0aW5nX01HVTVNbUkyWkdZdE9XWm1PQzAwWTJabUxXSmxPVAogSXROalV4TmpB

+NVlqVXlZVFl5LXRocmVhZC52MiExNDQ2NGQwOWNlYjg0NThjYTYxYzcxN2YxZTVjNjZjNSEyZmQw

+YzFjNTI4ZTEKIDQwYzQ5ZjBkYTAzNjNjYTgwYTNjClgtTUlDUk9TT0ZULU9OTElORU1FRVRJTkdJ

+TkZPUk1BVElPTjp7Ik9ubGluZU1lZXRpbmdDaGFubmVsSWQiOm51bGxcLCJPbmxpbgogZU1lZXRp

+bmdQcm92aWRlciI6M30KWC1NSUNST1NPRlQtRE9OT1RGT1JXQVJETUVFVElORzpGQUxTRQpYLU1J

+Q1JPU09GVC1ESVNBTExPVy1DT1VOVEVSOkZBTFNFClgtTUlDUk9TT0ZULUxPQ0FUSU9OUzpbXQpC

+RUdJTjpWQUxBUk0KREVTQ1JJUFRJT046UkVNSU5ERVIKVFJJR0dFUjtSRUxBVEVEPVNUQVJUOi1Q

+VDE1TQpBQ1RJT046RElTUExBWQpFTkQ6VkFMQVJNCkVORDpWRVZFTlQKRU5EOlZDQUxFTkRBUgo=

+

+--_000_HE1PR0802MB228346BE1576FEAB8A7F32328EF30HE1PR0802MB2283_--

diff --git a/comm/calendar/test/browser/invitations/data/update-major.eml b/comm/calendar/test/browser/invitations/data/update-major.eml
new file mode 100644
index 0000000000..04754798b2
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/update-major.eml
@@ -0,0 +1,78 @@
+MIME-Version: 1.0
+Content-Transfer-Encoding: binary
+Content-Type: multipart/mixed; boundary="_----------=_1647458162153312762582"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+To: receiver@example.com
+Subject: Update Major
+From: Sender <sender@example.com>
+
+This is a multi-part message in MIME format.
+
+--_----------=_1647458162153312762582
+MIME-Version: 1.0
+Content-Transfer-Encoding: binary
+Content-Type: multipart/alternative; boundary="_----------=_1647458162153312762583"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+This is a multi-part message in MIME format.
+
+--_----------=_1647458162153312762583
+MIME-Version: 1.0
+Content-Disposition: inline
+Content-Length: 227
+Content-Transfer-Encoding: binary
+Content-Type: text/plain; charset="utf-8"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+Single Event
+
+When:
+    Wed, Mar 16 2022
+    11:00 - 12:00 AST
+Where:
+    Somewhere
+
+--_----------=_1647458162153312762583
+MIME-Version: 1.0
+Content-Disposition: inline
+Content-Transfer-Encoding: quoted-printable
+Content-Type: text/calendar; charset="utf-8"; method="REQUEST"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+BEGIN:VCALENDAR
+VERSION:2.0
+METHOD:REQUEST
+CALSCALE:GREGORIAN
+BEGIN:VEVENT
+UID:02e79b96
+SEQUENCE:2
+DTSTAMP:20220316T191602Z
+CREATED:20220316T191532Z
+DTSTART:20220316T050000Z
+DTEND:20220316T053000Z
+DURATION:PT1H
+PRIORITY:0
+SUMMARY:Single Event
+DESCRIPTION:An event invitation.
+LOCATION:Somewhere
+STATUS:CONFIRMED
+TRANSP:OPAQUE
+CLASS:PUBLIC
+ORGANIZER;CN=3DSender;
+ EMAIL=3Dsender@example.com:mailto:sender@example.com
+ATTENDEE;CN=3DSender;
+ EMAIL=3Dsender@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DACCEPTED;RSVP=3DFALSE:mailto:sender@example.com
+ATTENDEE;CN=Receiver;EMAIL=3Dreceiver@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DNEEDS-ACTION;RSVP=3DTRUE:mailto:receiver@example.com
+ATTENDEE;CN=Other;EMAIL=other@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DNEEDS-ACTION;RSVP=3DTRUE:mailto:other@example.com
+BEGIN:VALARM
+ACTION:DISPLAY
+TRIGGER:-P1D
+DESCRIPTION:This is an event reminder
+END:VALARM
+END:VEVENT
+END:VCALENDAR
+
+--_----------=_1647458162153312762583--
diff --git a/comm/calendar/test/browser/invitations/data/update-minor.eml b/comm/calendar/test/browser/invitations/data/update-minor.eml
new file mode 100644
index 0000000000..afeb8e9ba0
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/data/update-minor.eml
@@ -0,0 +1,78 @@
+MIME-Version: 1.0
+Content-Transfer-Encoding: binary
+Content-Type: multipart/mixed; boundary="_----------=_1647458162153312762582"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+To: receiver@example.com
+Subject: Update Minor
+From: Sender <sender@example.com>
+
+This is a multi-part message in MIME format.
+
+--_----------=_1647458162153312762582
+MIME-Version: 1.0
+Content-Transfer-Encoding: binary
+Content-Type: multipart/alternative; boundary="_----------=_1647458162153312762583"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+This is a multi-part message in MIME format.
+
+--_----------=_1647458162153312762583
+MIME-Version: 1.0
+Content-Disposition: inline
+Content-Length: 227
+Content-Transfer-Encoding: binary
+Content-Type: text/plain; charset="utf-8"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+Single Event
+
+When:
+    Wed, Mar 16 2022
+    11:00 - 12:00 AST
+Where:
+    Somewhere
+
+--_----------=_1647458162153312762583
+MIME-Version: 1.0
+Content-Disposition: inline
+Content-Transfer-Encoding: quoted-printable
+Content-Type: text/calendar; charset="utf-8"; method="REQUEST"
+Date: Wed, 16 Mar 2022 15:16:02 -0400
+
+BEGIN:VCALENDAR
+VERSION:2.0
+METHOD:REQUEST
+CALSCALE:GREGORIAN
+BEGIN:VEVENT
+UID:02e79b96
+SEQUENCE:0
+DTSTAMP:20220318T191602Z
+CREATED:20220316T191532Z
+DTSTART:20220316T110000Z
+DTEND:20220316T113000Z
+DURATION:PT1H
+PRIORITY:0
+SUMMARY:Updated Event
+DESCRIPTION:Updated description.
+LOCATION:Updated location
+STATUS:CONFIRMED
+TRANSP:OPAQUE
+CLASS:PUBLIC
+ORGANIZER;CN=3DSender;
+ EMAIL=3Dsender@example.com:mailto:sender@example.com
+ATTENDEE;CN=3DSender;
+ EMAIL=3Dsender@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DACCEPTED;RSVP=3DFALSE:mailto:sender@example.com
+ATTENDEE;CN=Receiver;EMAIL=3Dreceiver@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DNEEDS-ACTION;RSVP=3DTRUE:mailto:receiver@example.com
+ATTENDEE;CN=Other;EMAIL=other@example.com;CUTYPE=3DINDIVIDUAL;
+ PARTSTAT=3DNEEDS-ACTION;RSVP=3DTRUE:mailto:other@example.com
+BEGIN:VALARM
+ACTION:DISPLAY
+TRIGGER:-P1D
+DESCRIPTION:Updated description.
+END:VALARM
+END:VEVENT
+END:VCALENDAR
+
+--_----------=_1647458162153312762583--
diff --git a/comm/calendar/test/browser/invitations/head.js b/comm/calendar/test/browser/invitations/head.js
new file mode 100644
index 0000000000..24835c3021
--- /dev/null
+++ b/comm/calendar/test/browser/invitations/head.js
@@ -0,0 +1,942 @@
+/* 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/. */
+
+/**
+ * Common functions for the imip-bar tests.
+ *
+ * Note that these tests are heavily tied to the .eml files found in the data
+ * folder.
+ */
+
+"use strict";
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { CalItipDefaultEmailTransport } = ChromeUtils.import(
+  "resource:///modules/CalItipEmailTransport.jsm"
+);
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { FileTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/FileTestUtils.sys.mjs"
+);
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+registerCleanupFunction(async () => {
+  // Some tests that open new windows don't return focus to the main window
+  // in a way that satisfies mochitest, and the test times out.
+  Services.focus.focusedWindow = window;
+  document.body.focus();
+});
+
+class EmailTransport extends CalItipDefaultEmailTransport {
+  sentItems = [];
+
+  sentMsgs = [];
+
+  getMsgSend() {
+    let { sentMsgs } = this;
+    return {
+      sendMessageFile(
+        userIdentity,
+        accountKey,
+        composeFields,
+        messageFile,
+        deleteSendFileOnCompletion,
+        digest,
+        deliverMode,
+        msgToReplace,
+        listener,
+        statusFeedback,
+        smtpPassword
+      ) {
+        sentMsgs.push({
+          userIdentity,
+          accountKey,
+          composeFields,
+          messageFile,
+          deleteSendFileOnCompletion,
+          digest,
+          deliverMode,
+          msgToReplace,
+          listener,
+          statusFeedback,
+          smtpPassword,
+        });
+      },
+    };
+  }
+
+  sendItems(recipients, itipItem, fromAttendee) {
+    this.sentItems.push({ recipients, itipItem, fromAttendee });
+    return super.sendItems(recipients, itipItem, fromAttendee);
+  }
+
+  reset() {
+    this.sentItems = [];
+    this.sentMsgs = [];
+  }
+}
+
+async function openMessageFromFile(file) {
+  let fileURL = Services.io
+    .newFileURI(file)
+    .mutate()
+    .setQuery("type=application/x-message-display")
+    .finalize();
+
+  let winPromise = BrowserTestUtils.domWindowOpenedAndLoaded();
+  window.openDialog(
+    "chrome://messenger/content/messageWindow.xhtml",
+    "_blank",
+    "all,chrome,dialog=no,status,toolbar",
+    fileURL
+  );
+  let win = await winPromise;
+  await BrowserTestUtils.waitForEvent(win, "MsgLoaded");
+  await TestUtils.waitForCondition(() => Services.focus.activeWindow == win);
+  return win;
+}
+
+/**
+ * Opens an iMIP message file and waits for the imip-bar to appear.
+ *
+ * @param {nsIFile} file
+ * @returns {Window}
+ */
+async function openImipMessage(file) {
+  let win = await openMessageFromFile(file);
+  let aboutMessage = win.document.getElementById("messageBrowser").contentWindow;
+  let imipBar = aboutMessage.document.getElementById("imip-bar");
+  await TestUtils.waitForCondition(() => !imipBar.collapsed, "imip-bar shown");
+
+  if (Services.prefs.getBoolPref("calendar.itip.newInvitationDisplay")) {
+    // CalInvitationDisplay.show() does some async activities before the panel is added.
+    await TestUtils.waitForCondition(
+      () =>
+        win.document
+          .getElementById("messageBrowser")
+          .contentDocument.querySelector("calendar-invitation-panel"),
+      "calendar-invitation-panel shown"
+    );
+  }
+  return win;
+}
+
+/**
+ * Clicks on one of the imip-bar action buttons.
+ *
+ * @param {Window} win
+ * @param {string} id
+ */
+async function clickAction(win, id) {
+  let aboutMessage = win.document.getElementById("messageBrowser").contentWindow;
+  let action = aboutMessage.document.getElementById(id);
+  await TestUtils.waitForCondition(() => !action.hidden, `button "#${id}" shown`);
+
+  EventUtils.synthesizeMouseAtCenter(action, {}, aboutMessage);
+  await TestUtils.waitForCondition(() => action.hidden, `button "#${id}" hidden`);
+}
+
+/**
+ * Clicks on one of the imip-bar actions from a dropdown menu.
+ *
+ * @param {Window} win The window the imip message is opened in.
+ * @param {string} buttonId The id of the <toolbarbutton> containing the menu.
+ * @param {string} actionId The id of the menu item to click.
+ */
+async function clickMenuAction(win, buttonId, actionId) {
+  let aboutMessage = win.document.getElementById("messageBrowser").contentWindow;
+  let actionButton = aboutMessage.document.getElementById(buttonId);
+  await TestUtils.waitForCondition(() => !actionButton.hidden, `"${buttonId}" shown`);
+
+  let actionMenu = actionButton.querySelector("menupopup");
+  let menuShown = BrowserTestUtils.waitForEvent(actionMenu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(actionButton.querySelector("dropmarker"), {}, aboutMessage);
+  await menuShown;
+  actionMenu.activateItem(aboutMessage.document.getElementById(actionId));
+  await TestUtils.waitForCondition(() => actionButton.hidden, `action menu "#${buttonId}" hidden`);
+}
+
+const unpromotedProps = ["location", "description", "sequence", "x-moz-received-dtstamp"];
+
+/**
+ * An object where the keys are paths/selectors and the values are the values
+ * we expect to encounter.
+ *
+ * @typedef {object} Comparable
+ */
+
+/**
+ * Compares the paths specified in the expected object against the provided
+ * actual object.
+ *
+ * @param {object} actual This is expected to be a calIEvent or calIAttendee but
+ *   can also be an array of both etc.
+ * @param {Comparable} expected
+ */
+function compareProperties(actual, expected, prefix = "") {
+  Assert.equal(typeof actual, "object", `${prefix || "provided value"} is an object`);
+  for (let [key, value] of Object.entries(expected)) {
+    if (key.includes(".")) {
+      let keys = key.split(".");
+      let head = keys[0];
+      let tail = keys.slice(1).join(".");
+      compareProperties(actual[head], { [tail]: value }, [prefix, head].filter(k => k).join("."));
+      continue;
+    }
+
+    let path = [prefix, key].filter(k => k).join(".");
+    let actualValue = unpromotedProps.includes(key) ? actual.getProperty(key) : actual[key];
+    Assert.equal(actualValue, value, `property "${path}" is "${value}"`);
+  }
+}
+
+/**
+ * Compares the text contents of the selectors specified on the inviatation panel
+ * to the expected value for each.
+ *
+ * @param {ShadowRoot} root The invitation panel's ShadowRoot instance.
+ * @param {Comparable} expected
+ */
+function compareShownPanelValues(root, expected) {
+  for (let [key, value] of Object.entries(expected)) {
+    value = Array.isArray(value) ? value.join("") : value;
+    Assert.equal(
+      root.querySelector(key).textContent.trim(),
+      value,
+      `property "${key}" is "${value}"`
+    );
+  }
+}
+
+/**
+ * Clicks on one of the invitation panel action buttons.
+ *
+ * @param {Window} panel
+ * @param {string} id
+ * @param {boolean} sendResponse
+ */
+async function clickPanelAction(panel, id, sendResponse = true) {
+  let promise = BrowserTestUtils.promiseAlertDialogOpen(sendResponse ? "accept" : "cancel");
+  let button = panel.shadowRoot.getElementById(id);
+  EventUtils.synthesizeMouseAtCenter(button, {}, panel.ownerGlobal);
+  await promise;
+  await BrowserTestUtils.waitForEvent(panel.ownerGlobal, "onItipItemActionFinished");
+}
+
+/**
+ * Tests that an attempt to reply to the organizer of the event with the correct
+ * details occurred.
+ *
+ * @param {EmailTransport} transport
+ * @param {nsIdentity} identity
+ * @param {string} partStat
+ */
+async function doReplyTest(transport, identity, partStat) {
+  info("Verifying the attempt to send a response uses the correct data");
+  Assert.equal(transport.sentItems.length, 1, "itip subsystem attempted to send a response");
+  compareProperties(transport.sentItems[0], {
+    "recipients.0.id": "mailto:sender@example.com",
+    "itipItem.responseMethod": "REPLY",
+    "fromAttendee.id": "mailto:receiver@example.com",
+    "fromAttendee.participationStatus": partStat,
+  });
+
+  // The itipItem is used to generate the iTIP data in the message body.
+  info("Verifying the reply calItipItem attendee list");
+  let replyItem = transport.sentItems[0].itipItem.getItemList()[0];
+  let replyAttendees = replyItem.getAttendees();
+  Assert.equal(replyAttendees.length, 1, "reply has one attendee");
+  compareProperties(replyAttendees[0], {
+    id: "mailto:receiver@example.com",
+    participationStatus: partStat,
+  });
+
+  info("Verifying the call to the message subsystem");
+  Assert.equal(transport.sentMsgs.length, 1, "transport sent 1 message");
+  compareProperties(transport.sentMsgs[0], {
+    userIdentity: identity,
+    "composeFields.from": "receiver@example.com",
+    "composeFields.to": "Sender <sender@example.com>",
+  });
+  Assert.ok(transport.sentMsgs[0].messageFile.exists(), "message file was created");
+}
+
+/**
+ * @typedef {object} ImipBarActionTestConf
+ *
+ * @property {calICalendar} calendar The calendar used for the test.
+ * @property {calIItipTranport} transport The transport used for the test.
+ * @property {nsIIdentity} identity The identity expected to be used to
+ *   send the reply.
+ * @property {boolean} isRecurring Indicates whether to treat the event as a
+ *   recurring event or not.
+ * @property {string} partStat The participationStatus of the receiving user to
+ *   expect.
+ * @property {boolean} noReply If true, do not expect an attempt to send a reply.
+ * @property {boolean} noSend If true, expect the reply attempt to stop after the
+ *   user is prompted.
+ * @property {boolean} isMajor For update tests indicates if the changes expected
+ *  are major or minor.
+ */
+
+/**
+ * Test the properties of an event created from the imip-bar and optionally, the
+ * attempt to send a reply.
+ *
+ * @param {ImipBarActionTestConf} conf
+ * @param {calIEvent|calIEvent[]} item
+ */
+async function doImipBarActionTest(conf, event) {
+  let { calendar, transport, identity, partStat, isRecurring, noReply, noSend } = conf;
+  let events = [event];
+  let startDates = ["20220316T110000Z"];
+  let endDates = ["20220316T113000Z"];
+
+  if (isRecurring) {
+    startDates = [...startDates, "20220317T110000Z", "20220318T110000Z"];
+    endDates = [...endDates, "20220317T113000Z", "20220318T113000Z"];
+    events = event.parentItem.recurrenceInfo.getOccurrences(
+      cal.createDateTime("19700101"),
+      cal.createDateTime("30000101"),
+      Infinity
+    );
+    Assert.equal(events.length, 3, "reccurring event has 3 occurrences");
+  }
+
+  info("Verifying relevant properties of each event occurrence");
+  for (let [index, occurrence] of events.entries()) {
+    compareProperties(occurrence, {
+      id: "02e79b96",
+      title: isRecurring ? "Repeat Event" : "Single Event",
+      "calendar.name": calendar.name,
+      ...(isRecurring ? { "recurrenceId.icalString": startDates[index] } : {}),
+      "startDate.icalString": startDates[index],
+      "endDate.icalString": endDates[index],
+      description: "An event invitation.",
+      location: "Somewhere",
+      sequence: "0",
+      "x-moz-received-dtstamp": "20220316T191602Z",
+      "organizer.id": "mailto:sender@example.com",
+      status: "CONFIRMED",
+    });
+
+    // Alarms should be ignored.
+    Assert.equal(
+      occurrence.getAlarms().length,
+      0,
+      `${isRecurring ? "occurrence" : "event"} has no reminders`
+    );
+
+    info("Verifying attendee list and participation status");
+    let attendees = occurrence.getAttendees();
+    compareProperties(attendees, {
+      "0.id": "mailto:sender@example.com",
+      "0.participationStatus": "ACCEPTED",
+      "1.participationStatus": partStat,
+      "1.id": "mailto:receiver@example.com",
+      "2.id": "mailto:other@example.com",
+      "2.participationStatus": "NEEDS-ACTION",
+    });
+  }
+
+  if (noReply) {
+    Assert.equal(
+      transport.sentItems.length,
+      0,
+      "itip subsystem did not attempt to send a response"
+    );
+  }
+  if (noReply || noSend) {
+    Assert.equal(transport.sentMsgs.length, 0, "no call was made into the mail subsystem");
+    return;
+  }
+  await doReplyTest(transport, identity, partStat);
+}
+
+/**
+ * Tests the recognition and application of a minor update to an existing event.
+ * An update is considered minor if the SEQUENCE property has not changed but
+ * the DTSTAMP has.
+ *
+ * @param {ImipBarActionTestConf} conf
+ */
+async function doMinorUpdateTest(conf) {
+  let { transport, calendar, partStat, isRecurring } = conf;
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item.parentItem;
+  let prevEventIcs = event.icalString;
+
+  transport.reset();
+
+  let updatePath = isRecurring ? "data/repeat-update-minor.eml" : "data/update-minor.eml";
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath(updatePath)));
+  let aboutMessage = win.document.getElementById("messageBrowser").contentWindow;
+  let updateButton = aboutMessage.document.getElementById("imipUpdateButton");
+  Assert.ok(!updateButton.hidden, `#${updateButton.id} button shown`);
+  EventUtils.synthesizeMouseAtCenter(updateButton, {}, aboutMessage);
+
+  await TestUtils.waitForCondition(async () => {
+    event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item.parentItem;
+    return event.icalString != prevEventIcs;
+  }, "event updated");
+
+  await BrowserTestUtils.closeWindow(win);
+
+  let events = [event];
+  let startDates = ["20220316T110000Z"];
+  let endDates = ["20220316T113000Z"];
+  if (isRecurring) {
+    startDates = [...startDates, "20220317T110000Z", "20220318T110000Z"];
+    endDates = [...endDates, "20220317T113000Z", "20220318T113000Z"];
+    events = event.recurrenceInfo.getOccurrences(
+      cal.createDateTime("19700101"),
+      cal.createDateTime("30000101"),
+      Infinity
+    );
+    Assert.equal(events.length, 3, "reccurring event has 3 occurrences");
+  }
+
+  info("Verifying relevant properties of each event occurrence");
+  for (let [index, occurrence] of events.entries()) {
+    compareProperties(occurrence, {
+      id: "02e79b96",
+      title: "Updated Event",
+      "calendar.name": calendar.name,
+      ...(isRecurring ? { "recurrenceId.icalString": startDates[index] } : {}),
+      "startDate.icalString": startDates[index],
+      "endDate.icalString": endDates[index],
+      description: "Updated description.",
+      location: "Updated location",
+      sequence: "0",
+      "x-moz-received-dtstamp": "20220318T191602Z",
+      "organizer.id": "mailto:sender@example.com",
+      status: "CONFIRMED",
+    });
+
+    // Note: It seems we do not keep the order of the attendees list for updates.
+    let attendees = occurrence.getAttendees();
+    compareProperties(attendees, {
+      "0.id": "mailto:sender@example.com",
+      "0.participationStatus": "ACCEPTED",
+      "1.id": "mailto:other@example.com",
+      "1.participationStatus": "NEEDS-ACTION",
+      "2.participationStatus": partStat,
+      "2.id": "mailto:receiver@example.com",
+    });
+  }
+
+  Assert.equal(transport.sentItems.length, 0, "itip subsystem did not attempt to send a response");
+  Assert.equal(transport.sentMsgs.length, 0, "no call was made into the mail subsystem");
+  await calendar.deleteItem(event);
+}
+
+const actionIds = {
+  single: {
+    button: {
+      ACCEPTED: "imipAcceptButton",
+      TENTATIVE: "imipTentativeButton",
+      DECLINED: "imipDeclineButton",
+    },
+    noReply: {
+      ACCEPTED: "imipAcceptButton_AcceptDontSend",
+      TENTATIVE: "imipTentativeButton_TentativeDontSend",
+      DECLINED: "imipDeclineButton_DeclineDontSend",
+    },
+  },
+  recurring: {
+    button: {
+      ACCEPTED: "imipAcceptRecurrencesButton",
+      TENTATIVE: "imipTentativeRecurrencesButton",
+      DECLINED: "imipDeclineRecurrencesButton",
+    },
+    noReply: {
+      ACCEPTED: "imipAcceptRecurrencesButton_AcceptDontSend",
+      TENTATIVE: "imipTentativeRecurrencesButton_TentativeDontSend",
+      DECLINED: "imipDeclineRecurrencesButton_DeclineDontSend",
+    },
+  },
+};
+
+/**
+ * Tests the recognition and application of a major update to an existing event.
+ * An update is considered major if the SEQUENCE property has changed. For major
+ * updates, the imip-bar prompts the user to re-confirm their attendance.
+ *
+ * @param {ImipBarActionTestConf} conf
+ */
+async function doMajorUpdateTest(conf) {
+  let { transport, identity, calendar, partStat, isRecurring, noReply } = conf;
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item.parentItem;
+  let prevEventIcs = event.icalString;
+
+  transport.reset();
+
+  let updatePath = isRecurring ? "data/repeat-update-major.eml" : "data/update-major.eml";
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath(updatePath)));
+  let actions = isRecurring ? actionIds.recurring : actionIds.single;
+  if (noReply) {
+    let { button, noReply } = actions;
+    await clickMenuAction(win, button[partStat], noReply[partStat]);
+  } else {
+    await clickAction(win, actions.button[partStat]);
+  }
+
+  await TestUtils.waitForCondition(async () => {
+    event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item.parentItem;
+    return event.icalString != prevEventIcs;
+  }, "event updated");
+
+  await BrowserTestUtils.closeWindow(win);
+
+  if (noReply) {
+    Assert.equal(
+      transport.sentItems.length,
+      0,
+      "itip subsystem did not attempt to send a response"
+    );
+    Assert.equal(transport.sentMsgs.length, 0, "no call was made into the mail subsystem");
+  } else {
+    await doReplyTest(transport, identity, partStat);
+  }
+
+  let events = [event];
+  let startDates = ["20220316T050000Z"];
+  let endDates = ["20220316T053000Z"];
+  if (isRecurring) {
+    startDates = [...startDates, "20220317T050000Z", "20220318T050000Z"];
+    endDates = [...endDates, "20220317T053000Z", "20220318T053000Z"];
+    events = event.recurrenceInfo.getOccurrences(
+      cal.createDateTime("19700101"),
+      cal.createDateTime("30000101"),
+      Infinity
+    );
+    Assert.equal(events.length, 3, "reccurring event has 3 occurrences");
+  }
+
+  for (let [index, occurrence] of events.entries()) {
+    compareProperties(occurrence, {
+      id: "02e79b96",
+      title: isRecurring ? "Repeat Event" : "Single Event",
+      "calendar.name": calendar.name,
+      ...(isRecurring ? { "recurrenceId.icalString": startDates[index] } : {}),
+      "startDate.icalString": startDates[index],
+      "endDate.icalString": endDates[index],
+      description: "An event invitation.",
+      location: "Somewhere",
+      sequence: "2",
+      "x-moz-received-dtstamp": "20220316T191602Z",
+      "organizer.id": "mailto:sender@example.com",
+      status: "CONFIRMED",
+    });
+
+    let attendees = occurrence.getAttendees();
+    compareProperties(attendees, {
+      "0.id": "mailto:sender@example.com",
+      "0.participationStatus": "ACCEPTED",
+      "1.id": "mailto:other@example.com",
+      "1.participationStatus": "NEEDS-ACTION",
+      "2.participationStatus": partStat,
+      "2.id": "mailto:receiver@example.com",
+    });
+  }
+  await calendar.deleteItem(event);
+}
+
+/**
+ * Tests the recognition and application of a minor update exception to an
+ * existing recurring event.
+ *
+ * @param {ImipBarActionTestConf} conf
+ */
+async function doMinorExceptionTest(conf) {
+  let { transport, calendar, partStat } = conf;
+  let recurrenceId = cal.createDateTime("20220317T110000Z");
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item.parentItem;
+  let originalProps = {
+    id: "02e79b96",
+    "recurrenceId.icalString": "20220317T110000Z",
+    title: event.title,
+    "calendar.name": calendar.name,
+    "startDate.icalString": event.startDate.icalString,
+    "endDate.icalString": event.endDate.icalString,
+    description: event.getProperty("DESCRIPTION"),
+    location: event.getProperty("LOCATION"),
+    sequence: "0",
+    "x-moz-received-dtstamp": event.getProperty("x-moz-received-dtstamp"),
+    "organizer.id": "mailto:sender@example.com",
+    status: "CONFIRMED",
+  };
+
+  Assert.ok(
+    !event.recurrenceInfo.getExceptionFor(recurrenceId),
+    `no exception exists for ${recurrenceId}`
+  );
+
+  transport.reset();
+
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-minor.eml")));
+  let aboutMessage = win.document.getElementById("messageBrowser").contentWindow;
+  let updateButton = aboutMessage.document.getElementById("imipUpdateButton");
+  Assert.ok(!updateButton.hidden, `#${updateButton.id} button shown`);
+  EventUtils.synthesizeMouseAtCenter(updateButton, {}, aboutMessage);
+
+  let exception;
+  await TestUtils.waitForCondition(async () => {
+    event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item.parentItem;
+    exception = event.recurrenceInfo.getExceptionFor(recurrenceId);
+    return exception;
+  }, "event exception applied");
+
+  await BrowserTestUtils.closeWindow(win);
+
+  Assert.equal(transport.sentItems.length, 0, "itip subsystem did not attempt to send a response");
+  Assert.equal(transport.sentMsgs.length, 0, "no call was made into the mail subsystem");
+
+  info("Verifying relevant properties of the exception");
+  compareProperties(exception, {
+    id: "02e79b96",
+    "recurrenceId.icalString": "20220317T110000Z",
+    title: "Exception title",
+    "calendar.name": calendar.name,
+    "startDate.icalString": "20220317T110000Z",
+    "endDate.icalString": "20220317T113000Z",
+    description: "Exception description",
+    location: "Exception location",
+    sequence: "0",
+    "x-moz-received-dtstamp": "20220318T191602Z",
+    "organizer.id": "mailto:sender@example.com",
+    status: "CONFIRMED",
+  });
+
+  compareProperties(exception.getAttendees(), {
+    "0.id": "mailto:sender@example.com",
+    "0.participationStatus": "ACCEPTED",
+    "1.id": "mailto:other@example.com",
+    "1.participationStatus": "NEEDS-ACTION",
+    "2.id": "mailto:receiver@example.com",
+    "2.participationStatus": partStat,
+  });
+
+  let occurrences = event.recurrenceInfo.getOccurrences(
+    cal.createDateTime("19700101"),
+    cal.createDateTime("30000101"),
+    Infinity
+  );
+  Assert.equal(occurrences.length, 3, "reccurring event still has 3 occurrences");
+
+  info("Verifying relevant properties of the other occurrences");
+
+  let startDates = ["20220316T110000Z", "20220317T110000Z", "20220318T110000Z"];
+  let endDates = ["20220316T113000Z", "20220317T113000Z", "20220318T113000Z"];
+  for (let [index, occurrence] of occurrences.entries()) {
+    if (occurrence.startDate.compare(recurrenceId) == 0) {
+      continue;
+    }
+    compareProperties(occurrence, {
+      ...originalProps,
+      "recurrenceId.icalString": startDates[index],
+      "startDate.icalString": startDates[index],
+      "endDate.icalString": endDates[index],
+    });
+
+    let attendees = occurrence.getAttendees();
+    compareProperties(attendees, {
+      "0.id": "mailto:sender@example.com",
+      "0.participationStatus": "ACCEPTED",
+      "1.id": "mailto:receiver@example.com",
+      "1.participationStatus": partStat,
+      "2.id": "mailto:other@example.com",
+      "2.participationStatus": "NEEDS-ACTION",
+    });
+  }
+
+  await calendar.deleteItem(event);
+}
+
+/**
+ * Tests the recognition and application of a major update exception to an
+ * existing recurring event.
+ *
+ * @param {ImipBarActionTestConf} conf
+ */
+async function doMajorExceptionTest(conf) {
+  let { transport, identity, calendar, partStat, noReply } = conf;
+  let recurrenceId = cal.createDateTime("20220317T110000Z");
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item.parentItem;
+  let originalProps = {
+    id: "02e79b96",
+    "recurrenceId.icalString": "20220317T110000Z",
+    title: event.title,
+    "calendar.name": calendar.name,
+    "startDate.icalString": event.startDate.icalString,
+    "endDate.icalString": event.endDate.icalString,
+    description: event.getProperty("DESCRIPTION"),
+    location: event.getProperty("LOCATION"),
+    sequence: "0",
+    "x-moz-received-dtstamp": event.getProperty("x-moz-received-dtstamp"),
+    "organizer.id": "mailto:sender@example.com",
+    status: "CONFIRMED",
+  };
+  let originalPartStat = event
+    .getAttendees()
+    .find(att => att.id == "mailto:receiver@example.com").participationStatus;
+
+  Assert.ok(
+    !event.recurrenceInfo.getExceptionFor(recurrenceId),
+    `no exception exists for ${recurrenceId}`
+  );
+
+  transport.reset();
+
+  let win = await openImipMessage(new FileUtils.File(getTestFilePath("data/exception-major.eml")));
+  if (noReply) {
+    let { button, noReply } = actionIds.single;
+    await clickMenuAction(win, button[partStat], noReply[partStat]);
+  } else {
+    await clickAction(win, actionIds.single.button[partStat]);
+  }
+
+  let exception;
+  await TestUtils.waitForCondition(async () => {
+    event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item.parentItem;
+    exception = event.recurrenceInfo.getExceptionFor(recurrenceId);
+    return exception;
+  }, "event exception applied");
+
+  await BrowserTestUtils.closeWindow(win);
+
+  if (noReply) {
+    Assert.equal(
+      transport.sentItems.length,
+      0,
+      "itip subsystem did not attempt to send a response"
+    );
+    Assert.equal(transport.sentMsgs.length, 0, "no call was made into the mail subsystem");
+  } else {
+    await doReplyTest(transport, identity, partStat);
+  }
+
+  info("Verifying relevant properties of the exception");
+
+  compareProperties(exception, {
+    ...originalProps,
+    "startDate.icalString": "20220317T050000Z",
+    "endDate.icalString": "20220317T053000Z",
+    sequence: "2",
+  });
+
+  compareProperties(exception.getAttendees(), {
+    "0.id": "mailto:sender@example.com",
+    "0.participationStatus": "ACCEPTED",
+    "1.id": "mailto:other@example.com",
+    "1.participationStatus": "NEEDS-ACTION",
+    "2.id": "mailto:receiver@example.com",
+    "2.participationStatus": partStat,
+  });
+
+  let occurrences = event.recurrenceInfo.getOccurrences(
+    cal.createDateTime("19700101"),
+    cal.createDateTime("30000101"),
+    Infinity
+  );
+  Assert.equal(occurrences.length, 3, "reccurring event still has 3 occurrences");
+
+  info("Verifying relevant properties of the other occurrences");
+
+  let startDates = ["20220316T110000Z", "20220317T110000Z", "20220318T110000Z"];
+  let endDates = ["20220316T113000Z", "20220317T113000Z", "20220318T113000Z"];
+  for (let [index, occurrence] of occurrences.entries()) {
+    if (occurrence.startDate.icalString == "20220317T050000Z") {
+      continue;
+    }
+    compareProperties(occurrence, {
+      ...originalProps,
+      "recurrenceId.icalString": startDates[index],
+      "startDate.icalString": startDates[index],
+      "endDate.icalString": endDates[index],
+    });
+
+    let attendees = occurrence.getAttendees();
+    compareProperties(attendees, {
+      "0.id": "mailto:sender@example.com",
+      "0.participationStatus": "ACCEPTED",
+      "1.id": "mailto:receiver@example.com",
+      "1.participationStatus": originalPartStat,
+      "2.id": "mailto:other@example.com",
+      "2.participationStatus": "NEEDS-ACTION",
+    });
+  }
+
+  await calendar.deleteItem(event);
+}
+
+/**
+ * Test the properties of an event created from a minor or major exception where
+ * we have not added the original event and optionally, the attempt to send a
+ * reply.
+ *
+ * @param {ImipBarActionTestConf} conf
+ */
+async function doExceptionOnlyTest(conf) {
+  let { calendar, transport, identity, partStat, noReply, isMajor } = conf;
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 5, 1)).item;
+
+  // Exceptions are still created as recurring events.
+  Assert.ok(event != event.parentItem, "event created is a recurring event");
+  let occurrences = event.parentItem.recurrenceInfo.getOccurrences(
+    cal.createDateTime("10000101"),
+    cal.createDateTime("30000101"),
+    Infinity
+  );
+  Assert.equal(occurrences.length, 1, "parent item only has one occurrence");
+  Assert.ok(occurrences[0] == event, "occurrence is the event exception");
+
+  info("Verifying relevant properties of the event");
+  compareProperties(event, {
+    id: "02e79b96",
+    title: isMajor ? event.title : "Exception title",
+    "calendar.name": calendar.name,
+    "recurrenceId.icalString": "20220317T110000Z",
+    "startDate.icalString": isMajor ? "20220317T050000Z" : "20220317T110000Z",
+    "endDate.icalString": isMajor ? "20220317T053000Z" : "20220317T113000Z",
+    description: isMajor ? event.getProperty("DESCRIPTION") : "Exception description",
+    location: isMajor ? event.getProperty("LOCATION") : "Exception location",
+    sequence: isMajor ? "2" : "0",
+    "x-moz-received-dtstamp": isMajor
+      ? event.getProperty("x-moz-received-dtstamp")
+      : "20220318T191602Z",
+    "organizer.id": "mailto:sender@example.com",
+    status: "CONFIRMED",
+  });
+
+  // Alarms should be ignored.
+  Assert.equal(event.getAlarms().length, 0, "event has no reminders");
+
+  info("Verifying attendee list and participation status");
+  let attendees = event.getAttendees();
+  compareProperties(attendees, {
+    "0.id": "mailto:sender@example.com",
+    "0.participationStatus": "ACCEPTED",
+    "1.participationStatus": partStat,
+    "1.id": "mailto:receiver@example.com",
+    "2.id": "mailto:other@example.com",
+    "2.participationStatus": "NEEDS-ACTION",
+  });
+
+  if (noReply) {
+    Assert.equal(
+      transport.sentItems.length,
+      0,
+      "itip subsystem did not attempt to send a response"
+    );
+    Assert.equal(transport.sentMsgs.length, 0, "no call was made into the mail subsystem");
+  } else {
+    await doReplyTest(transport, identity, partStat);
+  }
+  await calendar.deleteItem(event.parentItem);
+}
+
+/**
+ * Tests the recognition and application of a cancellation to an existing event.
+ *
+ * @param {ImipBarActionTestConf} conf
+ */
+async function doCancelTest({ transport, calendar, isRecurring, event, recurrenceId }) {
+  transport.reset();
+
+  let eventId = event.id;
+  if (isRecurring) {
+    // wait for the other occurrences to appear.
+    await CalendarTestUtils.monthView.waitForItemAt(window, 3, 5, 1);
+    await CalendarTestUtils.monthView.waitForItemAt(window, 3, 6, 1);
+  }
+
+  let cancellationPath = isRecurring
+    ? "data/cancel-repeat-event.eml"
+    : "data/cancel-single-event.eml";
+
+  let cancelMsgFile = new FileUtils.File(getTestFilePath(cancellationPath));
+  if (recurrenceId) {
+    let srcTxt = await IOUtils.readUTF8(cancelMsgFile.path);
+    srcTxt = srcTxt.replaceAll(/RRULE:.+/g, `RECURRENCE-ID:${recurrenceId}`);
+    srcTxt = srcTxt.replaceAll(/SEQUENCE:.+/g, "SEQUENCE:3");
+    cancelMsgFile = FileTestUtils.getTempFile("cancel-occurrence.eml");
+    await IOUtils.writeUTF8(cancelMsgFile.path, srcTxt);
+  }
+
+  let win = await openImipMessage(cancelMsgFile);
+  let aboutMessage = win.document.getElementById("messageBrowser").contentWindow;
+  let deleteButton = aboutMessage.document.getElementById("imipDeleteButton");
+  Assert.ok(!deleteButton.hidden, `#${deleteButton.id} button shown`);
+  EventUtils.synthesizeMouseAtCenter(deleteButton, {}, aboutMessage);
+
+  if (isRecurring && recurrenceId) {
+    // Expects a single occurrence to be cancelled.
+
+    let occurrences;
+    await TestUtils.waitForCondition(async () => {
+      let { parentItem } = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item;
+      occurrences = parentItem.recurrenceInfo.getOccurrences(
+        cal.createDateTime("19700101"),
+        cal.createDateTime("30000101"),
+        Infinity
+      );
+      return occurrences.length == 2;
+    }, "occurrence was deleted");
+
+    Assert.ok(
+      occurrences.every(occ => occ.recurrenceId && occ.recurrenceId != recurrenceId),
+      `occurrence "${recurrenceId}" removed`
+    );
+    Assert.ok(!!(await calendar.getItem(eventId)), "event was not deleted");
+  } else {
+    await CalendarTestUtils.monthView.waitForNoItemAt(window, 3, 4, 1);
+
+    if (isRecurring) {
+      await CalendarTestUtils.monthView.waitForNoItemAt(window, 3, 5, 1);
+      await CalendarTestUtils.monthView.waitForNoItemAt(window, 3, 6, 1);
+    }
+
+    await TestUtils.waitForCondition(async () => {
+      let result = await calendar.getItem(eventId);
+      return !result;
+    }, "event was deleted");
+  }
+
+  await BrowserTestUtils.closeWindow(win);
+  Assert.equal(transport.sentItems.length, 0, "itip subsystem did not attempt to send a response");
+  Assert.equal(transport.sentMsgs.length, 0, "no call was made into the mail subsystem");
+}
+
+/**
+ * Tests processing of cancellations to exceptions to recurring events.
+ *
+ * @param {ImipBarActionTestConf} conf
+ */
+async function doCancelExceptionTest(conf) {
+  let { partStat, recurrenceId, calendar } = conf;
+  let invite = new FileUtils.File(getTestFilePath("data/repeat-event.eml"));
+  let win = await openImipMessage(invite);
+  await clickAction(win, actionIds.recurring.button[partStat]);
+
+  let event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item.parentItem;
+  await BrowserTestUtils.closeWindow(win);
+
+  let update = new FileUtils.File(getTestFilePath("data/exception-major.eml"));
+  let updateWin = await openImipMessage(update);
+  await clickAction(updateWin, actionIds.single.button[partStat]);
+
+  let exception;
+  await TestUtils.waitForCondition(async () => {
+    event = (await CalendarTestUtils.monthView.waitForItemAt(window, 3, 4, 1)).item.parentItem;
+    exception = event.recurrenceInfo.getExceptionFor(cal.createDateTime(recurrenceId));
+    return !!exception;
+  }, "exception applied");
+
+  await BrowserTestUtils.closeWindow(updateWin);
+  await doCancelTest({ ...conf, event });
+  await calendar.deleteItem(event);
+}
diff --git a/comm/calendar/test/browser/preferences/browser.ini b/comm/calendar/test/browser/preferences/browser.ini
new file mode 100644
index 0000000000..a06213b220
--- /dev/null
+++ b/comm/calendar/test/browser/preferences/browser.ini
@@ -0,0 +1,16 @@
+[default]
+head = head.js
+prefs =
+  calendar.item.promptDelete=false
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+  calendar.week.start=0
+  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_alarmDefaultValue.js]
+[browser_categoryColors.js]
diff --git a/comm/calendar/test/browser/preferences/browser_alarmDefaultValue.js b/comm/calendar/test/browser/preferences/browser_alarmDefaultValue.js
new file mode 100644
index 0000000000..b1cde7cf11
--- /dev/null
+++ b/comm/calendar/test/browser/preferences/browser_alarmDefaultValue.js
@@ -0,0 +1,176 @@
+/* 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/. */
+
+/**
+ * Test default alarm settings for events and tasks
+ */
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+var { cancelItemDialog } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+const DEFVALUE = 43;
+
+add_task(async function testDefaultAlarms() {
+  let calendar = CalendarTestUtils.createCalendar("Mochitest", "memory");
+  calendar.setProperty("calendar-main-default", true);
+  registerCleanupFunction(async () => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  let localeUnitString = cal.l10n.getCalString("unitDays");
+  let unitString = PluralForm.get(DEFVALUE, localeUnitString).replace("#1", DEFVALUE);
+  let alarmString = (...args) => cal.l10n.getString("calendar-alarms", ...args);
+  let originStringEvent = alarmString("reminderCustomOriginBeginBeforeEvent");
+  let originStringTask = alarmString("reminderCustomOriginBeginBeforeTask");
+  let expectedEventReminder = alarmString("reminderCustomTitle", [unitString, originStringEvent]);
+  let expectedTaskReminder = alarmString("reminderCustomTitle", [unitString, originStringTask]);
+
+  // Configure the preferences.
+  let { prefsWindow, prefsDocument } = await openNewPrefsTab("paneCalendar", "defaultsnoozelength");
+  await handlePrefTab(prefsWindow, prefsDocument);
+
+  // Create New Event.
+  await CalendarTestUtils.openCalendarTab(window);
+
+  let { dialogWindow, iframeWindow, iframeDocument } = await CalendarTestUtils.editNewEvent(window);
+
+  Assert.equal(iframeDocument.querySelector(".item-alarm").value, "custom");
+  let reminderDetails = iframeDocument.querySelector(".reminder-single-alarms-label");
+  Assert.equal(reminderDetails.value, expectedEventReminder);
+
+  let reminderDialogPromise = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-event-dialog-reminder.xhtml",
+    { callback: handleReminderDialog }
+  );
+  EventUtils.synthesizeMouseAtCenter(reminderDetails, {}, iframeWindow);
+  await reminderDialogPromise;
+
+  let promptPromise = BrowserTestUtils.promiseAlertDialog("extra1");
+  cancelItemDialog(dialogWindow);
+  await promptPromise;
+
+  // Create New Task.
+  await openTasksTab();
+  ({ dialogWindow, iframeWindow, iframeDocument } = await CalendarTestUtils.editNewTask(window));
+
+  Assert.equal(iframeDocument.querySelector(".item-alarm").value, "custom");
+  reminderDetails = iframeDocument.querySelector(".reminder-single-alarms-label");
+  Assert.equal(reminderDetails.value, expectedTaskReminder);
+
+  reminderDialogPromise = BrowserTestUtils.promiseAlertDialog(
+    null,
+    "chrome://calendar/content/calendar-event-dialog-reminder.xhtml",
+    { callback: handleReminderDialog }
+  );
+  EventUtils.synthesizeMouseAtCenter(reminderDetails, {}, iframeWindow);
+  await reminderDialogPromise;
+
+  promptPromise = BrowserTestUtils.promiseAlertDialog("extra1");
+  cancelItemDialog(dialogWindow);
+  await promptPromise;
+});
+
+async function handlePrefTab(prefsWindow, prefsDocument) {
+  function menuList(id, value) {
+    let list = prefsDocument.getElementById(id);
+    list.scrollIntoView();
+    list.click();
+    list.querySelector(`menuitem[value="${value}"]`).click();
+  }
+  // Turn on alarms for events and tasks.
+  menuList("eventdefalarm", "1");
+  menuList("tododefalarm", "1");
+
+  // Selects "days" as a unit.
+  menuList("tododefalarmunit", "days");
+  menuList("eventdefalarmunit", "days");
+
+  function text(id, value) {
+    let input = prefsDocument.getElementById(id);
+    input.scrollIntoView();
+    EventUtils.synthesizeMouse(input, 5, 5, {}, prefsWindow);
+    Assert.equal(prefsDocument.activeElement, input);
+    EventUtils.synthesizeKey("a", { accelKey: true }, prefsWindow);
+    EventUtils.sendString(value, prefsWindow);
+  }
+  // Sets default alarm length for events to DEFVALUE.
+  text("eventdefalarmlen", DEFVALUE.toString());
+  text("tododefalarmlen", DEFVALUE.toString());
+
+  Assert.equal(Services.prefs.getIntPref("calendar.alarms.onforevents"), 1);
+  Assert.equal(Services.prefs.getIntPref("calendar.alarms.eventalarmlen"), DEFVALUE);
+  Assert.equal(Services.prefs.getStringPref("calendar.alarms.eventalarmunit"), "days");
+  Assert.equal(Services.prefs.getIntPref("calendar.alarms.onfortodos"), 1);
+  Assert.equal(Services.prefs.getIntPref("calendar.alarms.todoalarmlen"), DEFVALUE);
+  Assert.equal(Services.prefs.getStringPref("calendar.alarms.todoalarmunit"), "days");
+}
+
+async function handleReminderDialog(remindersWindow) {
+  await new Promise(remindersWindow.setTimeout);
+  let remindersDocument = remindersWindow.document;
+
+  let listbox = remindersDocument.getElementById("reminder-listbox");
+  Assert.equal(listbox.selectedCount, 1);
+  Assert.equal(listbox.selectedItem.reminder.offset.days, DEFVALUE);
+
+  EventUtils.synthesizeMouseAtCenter(
+    remindersDocument.getElementById("reminder-new-button"),
+    {},
+    remindersWindow
+  );
+  Assert.equal(listbox.itemCount, 2);
+  Assert.equal(listbox.selectedCount, 1);
+  Assert.equal(listbox.selectedItem.reminder.offset.days, DEFVALUE);
+
+  function text(id, value) {
+    let input = remindersDocument.getElementById(id);
+    EventUtils.synthesizeMouse(input, 5, 5, {}, remindersWindow);
+    Assert.equal(remindersDocument.activeElement, input);
+    EventUtils.synthesizeKey("a", { accelKey: true }, remindersWindow);
+    EventUtils.sendString(value, remindersWindow);
+  }
+  text("reminder-length", "20");
+  Assert.equal(listbox.selectedItem.reminder.offset.days, 20);
+
+  EventUtils.synthesizeMouseAtCenter(listbox, {}, remindersWindow);
+  EventUtils.synthesizeKey("VK_UP", {}, remindersWindow);
+  Assert.equal(listbox.selectedIndex, 0);
+
+  Assert.equal(listbox.selectedItem.reminder.offset.days, DEFVALUE);
+
+  remindersDocument.querySelector("dialog").getButton("accept").click();
+}
+
+async function openTasksTab() {
+  let tabmail = document.getElementById("tabmail");
+  let tasksMode = tabmail.tabModes.tasks;
+
+  if (tasksMode.tabs.length == 1) {
+    tabmail.selectedTab = tasksMode.tabs[0];
+  } else {
+    let tasksTabButton = document.getElementById("tasksButton");
+    EventUtils.synthesizeMouseAtCenter(tasksTabButton, { clickCount: 1 });
+  }
+
+  is(tasksMode.tabs.length, 1, "tasks tab is open");
+  is(tabmail.selectedTab, tasksMode.tabs[0], "tasks tab is selected");
+
+  await new Promise(resolve => setTimeout(resolve));
+}
+
+registerCleanupFunction(function () {
+  Services.prefs.clearUserPref("calendar.alarms.onforevents");
+  Services.prefs.clearUserPref("calendar.alarms.eventalarmlen");
+  Services.prefs.clearUserPref("calendar.alarms.eventalarmunit");
+  Services.prefs.clearUserPref("calendar.alarms.onfortodos");
+  Services.prefs.clearUserPref("calendar.alarms.todoalarmlen");
+  Services.prefs.clearUserPref("calendar.alarms.todoalarmunit");
+});
diff --git a/comm/calendar/test/browser/preferences/browser_categoryColors.js b/comm/calendar/test/browser/preferences/browser_categoryColors.js
new file mode 100644
index 0000000000..29ad21ce13
--- /dev/null
+++ b/comm/calendar/test/browser/preferences/browser_categoryColors.js
@@ -0,0 +1,90 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+add_task(async function testCategoryColors() {
+  let calendar = CalendarTestUtils.createCalendar("Mochitest", "memory");
+
+  registerCleanupFunction(async () => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  let { prefsWindow, prefsDocument } = await openNewPrefsTab("paneCalendar", "categorieslist");
+
+  let listBox = prefsDocument.getElementById("categorieslist");
+  Assert.equal(listBox.itemChildren.length, 22);
+
+  for (let item of listBox.itemChildren) {
+    info(`${item.firstElementChild.value}: ${item.lastElementChild.style.backgroundColor}`);
+    Assert.ok(item.lastElementChild.style.backgroundColor);
+  }
+
+  // Edit the name and colour of a built-in category.
+
+  let subDialogPromise = BrowserTestUtils.waitForEvent(
+    prefsWindow.gSubDialog._dialogStack,
+    "dialogopen"
+  );
+
+  EventUtils.synthesizeMouse(listBox, 5, 5, {}, prefsWindow);
+  Assert.equal(listBox.selectedIndex, 0);
+  EventUtils.synthesizeMouseAtCenter(prefsDocument.getElementById("editCButton"), {}, prefsWindow);
+
+  await subDialogPromise;
+
+  let subDialogBrowser = prefsWindow.gSubDialog._topDialog._frame;
+  let subDialogDocument = subDialogBrowser.contentDocument;
+  subDialogDocument.getElementById("categoryName").value = "ZZZ Mochitest";
+  subDialogDocument.getElementById("categoryColor").value = "#00CC00";
+  subDialogDocument.body.firstElementChild.getButton("accept").click();
+
+  let listItem = listBox.itemChildren[listBox.itemCount - 1];
+  Assert.equal(listBox.selectedItem, listItem);
+  Assert.equal(listItem.firstElementChild.value, "ZZZ Mochitest");
+  Assert.equal(listItem.lastElementChild.style.backgroundColor, "rgb(0, 204, 0)");
+  Assert.equal(Services.prefs.getCharPref("calendar.category.color.zzz_mochitest"), "#00cc00");
+
+  // Remove the colour of a built-in category.
+
+  subDialogPromise = BrowserTestUtils.waitForEvent(
+    prefsWindow.gSubDialog._dialogStack,
+    "dialogopen"
+  );
+
+  EventUtils.synthesizeMouse(listBox, 5, 5, {}, prefsWindow);
+  EventUtils.synthesizeKey("VK_HOME", {}, prefsWindow);
+  Assert.equal(listBox.selectedIndex, 0);
+  let itemName = listBox.itemChildren[0].firstElementChild.value;
+  EventUtils.synthesizeMouseAtCenter(prefsDocument.getElementById("editCButton"), {}, prefsWindow);
+
+  await subDialogPromise;
+
+  subDialogBrowser = prefsWindow.gSubDialog._topDialog._frame;
+  await new Promise(subDialogBrowser.contentWindow.setTimeout);
+  subDialogDocument = subDialogBrowser.contentDocument;
+  subDialogDocument.getElementById("useColor").checked = false;
+  subDialogDocument.body.firstElementChild.getButton("accept").click();
+
+  listItem = listBox.itemChildren[0];
+  Assert.equal(listBox.selectedItem, listItem);
+  Assert.equal(listItem.firstElementChild.value, itemName);
+  Assert.equal(listItem.lastElementChild.style.backgroundColor, "");
+  Assert.equal(Services.prefs.getCharPref(`calendar.category.color.${itemName.toLowerCase()}`), "");
+
+  // Remove the added category.
+
+  EventUtils.synthesizeMouse(listBox, 5, 5, {}, prefsWindow);
+  EventUtils.synthesizeKey("VK_END", {}, prefsWindow);
+  Assert.equal(listBox.selectedIndex, listBox.itemCount - 1);
+  EventUtils.synthesizeMouseAtCenter(
+    prefsDocument.getElementById("deleteCButton"),
+    {},
+    prefsWindow
+  );
+});
diff --git a/comm/calendar/test/browser/preferences/head.js b/comm/calendar/test/browser/preferences/head.js
new file mode 100644
index 0000000000..8d6d5d3ab5
--- /dev/null
+++ b/comm/calendar/test/browser/preferences/head.js
@@ -0,0 +1,64 @@
+/* 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/. */
+
+/* globals openPreferencesTab */
+
+async function openNewPrefsTab(paneID, scrollPaneTo, otherArgs) {
+  let tabmail = document.getElementById("tabmail");
+  let prefsTabMode = tabmail.tabModes.preferencesTab;
+
+  Assert.equal(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");
+        resolve(subject);
+      }
+    }, "chrome-document-loaded");
+    openPreferencesTab(paneID, scrollPaneTo, otherArgs);
+  });
+  Assert.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));
+    Assert.equal(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));
+  if (scrollPaneTo) {
+    Assert.greater(
+      prefsDocument.getElementById("preferencesContainer").scrollTop,
+      0,
+      "Prefs page did scroll when it was supposed to"
+    );
+  }
+  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);
+  }
+}
diff --git a/comm/calendar/test/browser/providers/browser.ini b/comm/calendar/test/browser/providers/browser.ini
new file mode 100644
index 0000000000..84d6133696
--- /dev/null
+++ b/comm/calendar/test/browser/providers/browser.ini
@@ -0,0 +1,21 @@
+[default]
+head = head.js
+prefs =
+  calendar.item.promptDelete=false
+  calendar.debug.log=true
+  calendar.debug.log.verbose=true
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+  calendar.week.start=0
+  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_caldavCalendar_cached.js]
+[browser_caldavCalendar_uncached.js]
+[browser_icsCalendar_cached.js]
+[browser_icsCalendar_uncached.js]
+[browser_storageCalendar.js]
diff --git a/comm/calendar/test/browser/providers/browser_caldavCalendar_cached.js b/comm/calendar/test/browser/providers/browser_caldavCalendar_cached.js
new file mode 100644
index 0000000000..5b725e4d54
--- /dev/null
+++ b/comm/calendar/test/browser/providers/browser_caldavCalendar_cached.js
@@ -0,0 +1,64 @@
+/* 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 { CalDAVServer } = ChromeUtils.import("resource://testing-common/calendar/CalDAVServer.jsm");
+
+CalDAVServer.open("bob", "bob");
+if (!Services.logins.findLogins(CalDAVServer.origin, null, "test").length) {
+  // Save a username and password to the login manager.
+  let loginInfo = Cc["@mozilla.org/login-manager/loginInfo;1"].createInstance(Ci.nsILoginInfo);
+  loginInfo.init(CalDAVServer.origin, null, "test", "bob", "bob", "", "");
+  Services.logins.addLogin(loginInfo);
+}
+
+let calendar;
+add_setup(async function () {
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  calendar = createCalendar("caldav", CalDAVServer.url, true);
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  registerCleanupFunction(async () => {
+    // This test has issues cleaning up, and it breaks all the subsequent tests.
+    await new Promise(r => setTimeout(r, 1000)); // eslint-disable-line mozilla/no-arbitrary-setTimeout
+    await CalDAVServer.close();
+    Services.logins.removeAllLogins();
+    removeCalendar(calendar);
+  });
+});
+
+async function promiseIdle() {
+  await TestUtils.waitForCondition(() => !calendar.wrappedJSObject.mPendingSync);
+  await fetch(`${CalDAVServer.origin}/ping`);
+}
+
+add_task(async function testAlarms() {
+  calendarObserver._batchRequired = true;
+  await runTestAlarms(calendar);
+
+  // Be sure the calendar has finished deleting the event.
+  await promiseIdle();
+});
+
+add_task(async function testSyncChanges() {
+  await syncChangesTest.setUp();
+
+  await CalDAVServer.putItemInternal(
+    "ad0850e5-8020-4599-86a4-86c90af4e2cd.ics",
+    syncChangesTest.part1Item
+  );
+  await syncChangesTest.runPart1();
+
+  await CalDAVServer.putItemInternal(
+    "ad0850e5-8020-4599-86a4-86c90af4e2cd.ics",
+    syncChangesTest.part2Item
+  );
+  await syncChangesTest.runPart2();
+
+  CalDAVServer.deleteItemInternal("ad0850e5-8020-4599-86a4-86c90af4e2cd.ics");
+  await syncChangesTest.runPart3();
+
+  // Be sure the calendar has finished all requests.
+  await promiseIdle();
+});
diff --git a/comm/calendar/test/browser/providers/browser_caldavCalendar_uncached.js b/comm/calendar/test/browser/providers/browser_caldavCalendar_uncached.js
new file mode 100644
index 0000000000..7489ae4e09
--- /dev/null
+++ b/comm/calendar/test/browser/providers/browser_caldavCalendar_uncached.js
@@ -0,0 +1,61 @@
+/* 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 { CalDAVServer } = ChromeUtils.import("resource://testing-common/calendar/CalDAVServer.jsm");
+
+CalDAVServer.open("bob", "bob");
+if (!Services.logins.findLogins(CalDAVServer.origin, null, "test").length) {
+  // Save a username and password to the login manager.
+  let loginInfo = Cc["@mozilla.org/login-manager/loginInfo;1"].createInstance(Ci.nsILoginInfo);
+  loginInfo.init(CalDAVServer.origin, null, "test", "bob", "bob", "", "");
+  Services.logins.addLogin(loginInfo);
+}
+
+let calendar;
+add_setup(async function () {
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  calendar = createCalendar("caldav", CalDAVServer.url, false);
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  registerCleanupFunction(async () => {
+    await CalDAVServer.close();
+    Services.logins.removeAllLogins();
+    removeCalendar(calendar);
+  });
+});
+
+async function promiseIdle() {
+  await fetch(`${CalDAVServer.origin}/ping`);
+}
+
+add_task(async function testAlarms() {
+  calendarObserver._batchRequired = true;
+  await runTestAlarms(calendar);
+
+  // Be sure the calendar has finished deleting the event.
+  await promiseIdle();
+});
+
+add_task(async function testSyncChanges() {
+  await syncChangesTest.setUp();
+
+  await CalDAVServer.putItemInternal(
+    "ad0850e5-8020-4599-86a4-86c90af4e2cd.ics",
+    syncChangesTest.part1Item
+  );
+  await syncChangesTest.runPart1();
+
+  await CalDAVServer.putItemInternal(
+    "ad0850e5-8020-4599-86a4-86c90af4e2cd.ics",
+    syncChangesTest.part2Item
+  );
+  await syncChangesTest.runPart2();
+
+  CalDAVServer.deleteItemInternal("ad0850e5-8020-4599-86a4-86c90af4e2cd.ics");
+  await syncChangesTest.runPart3();
+
+  // Be sure the calendar has finished all requests.
+  await promiseIdle();
+});
diff --git a/comm/calendar/test/browser/providers/browser_icsCalendar_cached.js b/comm/calendar/test/browser/providers/browser_icsCalendar_cached.js
new file mode 100644
index 0000000000..ba788be5b9
--- /dev/null
+++ b/comm/calendar/test/browser/providers/browser_icsCalendar_cached.js
@@ -0,0 +1,73 @@
+/* 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 { ICSServer } = ChromeUtils.import("resource://testing-common/calendar/ICSServer.jsm");
+
+ICSServer.open("bob", "bob");
+if (!Services.logins.findLogins(ICSServer.origin, null, "test").length) {
+  // Save a username and password to the login manager.
+  let loginInfo = Cc["@mozilla.org/login-manager/loginInfo;1"].createInstance(Ci.nsILoginInfo);
+  loginInfo.init(ICSServer.origin, null, "test", "bob", "bob", "", "");
+  Services.logins.addLogin(loginInfo);
+}
+
+let calendar;
+add_setup(async function () {
+  // TODO: item notifications from a cached ICS calendar occur outside of batches.
+  // This isn't fatal but it shouldn't happen. Side-effects include alarms firing
+  // twice - once from onAddItem then again at onLoad.
+  //
+  // Remove the next line when this is fixed.
+  calendarObserver._batchRequired = false;
+
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  calendar = createCalendar("ics", ICSServer.url, true);
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  registerCleanupFunction(async () => {
+    await ICSServer.close();
+    Services.logins.removeAllLogins();
+    removeCalendar(calendar);
+  });
+});
+
+async function promiseIdle() {
+  await TestUtils.waitForCondition(
+    () =>
+      calendar.wrappedJSObject.mUncachedCalendar.wrappedJSObject._queue.length == 0 &&
+      calendar.wrappedJSObject.mUncachedCalendar.wrappedJSObject._isLocked === false
+  );
+  await fetch(`${ICSServer.origin}/ping`);
+}
+
+add_task(async function testAlarms() {
+  // Remove the next line when fixed.
+  calendarObserver._batchRequired = false;
+  await runTestAlarms(calendar);
+
+  // Be sure the calendar has finished deleting the event.
+  await promiseIdle();
+}).skip(); // Broken.
+
+add_task(async function testSyncChanges() {
+  await syncChangesTest.setUp();
+
+  await ICSServer.putICSInternal(syncChangesTest.part1Item);
+  await syncChangesTest.runPart1();
+
+  await ICSServer.putICSInternal(syncChangesTest.part2Item);
+  await syncChangesTest.runPart2();
+
+  await ICSServer.putICSInternal(
+    CalendarTestUtils.dedent`
+      BEGIN:VCALENDAR
+      END:VCALENDAR
+      `
+  );
+  await syncChangesTest.runPart3();
+
+  // Be sure the calendar has finished deleting the event.
+  await promiseIdle();
+});
diff --git a/comm/calendar/test/browser/providers/browser_icsCalendar_uncached.js b/comm/calendar/test/browser/providers/browser_icsCalendar_uncached.js
new file mode 100644
index 0000000000..ef25408dce
--- /dev/null
+++ b/comm/calendar/test/browser/providers/browser_icsCalendar_uncached.js
@@ -0,0 +1,64 @@
+/* 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 { ICSServer } = ChromeUtils.import("resource://testing-common/calendar/ICSServer.jsm");
+
+ICSServer.open("bob", "bob");
+if (!Services.logins.findLogins(ICSServer.origin, null, "test").length) {
+  // Save a username and password to the login manager.
+  let loginInfo = Cc["@mozilla.org/login-manager/loginInfo;1"].createInstance(Ci.nsILoginInfo);
+  loginInfo.init(ICSServer.origin, null, "test", "bob", "bob", "", "");
+  Services.logins.addLogin(loginInfo);
+}
+
+let calendar;
+add_setup(async function () {
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  calendar = createCalendar("ics", ICSServer.url, false);
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  registerCleanupFunction(async () => {
+    await ICSServer.close();
+    Services.logins.removeAllLogins();
+    removeCalendar(calendar);
+  });
+});
+
+async function promiseIdle() {
+  await TestUtils.waitForCondition(
+    () =>
+      calendar.wrappedJSObject._queue.length == 0 && calendar.wrappedJSObject._isLocked === false
+  );
+  await fetch(`${ICSServer.origin}/ping`);
+}
+
+add_task(async function testAlarms() {
+  calendarObserver._batchRequired = true;
+  await runTestAlarms(calendar);
+
+  // Be sure the calendar has finished deleting the event.
+  await promiseIdle();
+});
+
+add_task(async function testSyncChanges() {
+  await syncChangesTest.setUp();
+
+  await ICSServer.putICSInternal(syncChangesTest.part1Item);
+  await syncChangesTest.runPart1();
+
+  await ICSServer.putICSInternal(syncChangesTest.part2Item);
+  await syncChangesTest.runPart2();
+
+  await ICSServer.putICSInternal(
+    CalendarTestUtils.dedent`
+      BEGIN:VCALENDAR
+      END:VCALENDAR
+      `
+  );
+  await syncChangesTest.runPart3();
+
+  // Be sure the calendar has finished all requests.
+  await promiseIdle();
+});
diff --git a/comm/calendar/test/browser/providers/browser_storageCalendar.js b/comm/calendar/test/browser/providers/browser_storageCalendar.js
new file mode 100644
index 0000000000..1a9eb6a30c
--- /dev/null
+++ b/comm/calendar/test/browser/providers/browser_storageCalendar.js
@@ -0,0 +1,13 @@
+/* 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/. */
+
+let calendar = createCalendar("storage", "moz-storage-calendar://");
+registerCleanupFunction(() => {
+  removeCalendar(calendar);
+});
+
+add_task(function testAlarms() {
+  calendarObserver._batchRequired = false;
+  return runTestAlarms(calendar);
+});
diff --git a/comm/calendar/test/browser/providers/head.js b/comm/calendar/test/browser/providers/head.js
new file mode 100644
index 0000000000..bf58302131
--- /dev/null
+++ b/comm/calendar/test/browser/providers/head.js
@@ -0,0 +1,402 @@
+/* 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/. */
+
+SimpleTest.requestCompleteLog();
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+var { handleDeleteOccurrencePrompt } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarUtils.jsm"
+);
+
+var { saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+let calendarObserver = {
+  QueryInterface: ChromeUtils.generateQI(["calIObserver"]),
+
+  /* calIObserver */
+
+  _batchCount: 0,
+  _batchRequired: true,
+  onStartBatch(calendar) {
+    info(`onStartBatch ${calendar?.id} ${++this._batchCount}`);
+    Assert.equal(
+      calendar,
+      this._expectedCalendar,
+      "onStartBatch should occur on the expected calendar"
+    );
+  },
+  onEndBatch(calendar) {
+    info(`onEndBatch ${calendar?.id} ${this._batchCount--}`);
+    Assert.equal(
+      calendar,
+      this._expectedCalendar,
+      "onEndBatch should occur on the expected calendar"
+    );
+  },
+  onLoad(calendar) {
+    info(`onLoad ${calendar.id}`);
+    Assert.equal(calendar, this._expectedCalendar, "onLoad should occur on the expected calendar");
+    if (this._onLoadPromise) {
+      this._onLoadPromise.resolve();
+    }
+  },
+  onAddItem(item) {
+    info(`onAddItem ${item.calendar.id} ${item.id}`);
+    if (this._batchRequired) {
+      Assert.equal(this._batchCount, 1, "onAddItem must occur in a batch");
+    }
+  },
+  onModifyItem(newItem, oldItem) {
+    info(`onModifyItem ${newItem.calendar.id} ${newItem.id}`);
+    if (this._batchRequired) {
+      Assert.equal(this._batchCount, 1, "onModifyItem must occur in a batch");
+    }
+  },
+  onDeleteItem(deletedItem) {
+    info(`onDeleteItem ${deletedItem.calendar.id} ${deletedItem.id}`);
+  },
+  onError(calendar, errNo, message) {},
+  onPropertyChanged(calendar, name, value, oldValue) {},
+  onPropertyDeleting(calendar, name) {},
+};
+
+/**
+ * Create and register a calendar.
+ *
+ * @param {string} type - The calendar provider to use.
+ * @param {string} url - URL of the server.
+ * @param {boolean} useCache - Should this calendar have offline storage?
+ * @returns {calICalendar}
+ */
+function createCalendar(type, url, useCache) {
+  let calendar = cal.manager.createCalendar(type, Services.io.newURI(url));
+  calendar.name = type + (useCache ? " with cache" : " without cache");
+  calendar.id = cal.getUUID();
+  calendar.setProperty("cache.enabled", useCache);
+  calendar.setProperty("calendar-main-default", true);
+
+  cal.manager.registerCalendar(calendar);
+  calendar = cal.manager.getCalendarById(calendar.id);
+  calendarObserver._expectedCalendar = calendar;
+  calendar.addObserver(calendarObserver);
+
+  info(`Created calendar ${calendar.id}`);
+  return calendar;
+}
+
+/**
+ * Unregister a calendar.
+ *
+ * @param {calICalendar} calendar
+ */
+function removeCalendar(calendar) {
+  calendar.removeObserver(calendarObserver);
+  cal.manager.removeCalendar(calendar);
+}
+
+let alarmService = Cc["@mozilla.org/calendar/alarm-service;1"].getService(Ci.calIAlarmService);
+
+let alarmObserver = {
+  QueryInterface: ChromeUtils.generateQI(["calIAlarmServiceObserver"]),
+
+  /* calIAlarmServiceObserver */
+
+  _alarmCount: 0,
+  onAlarm(item, alarm) {
+    info("onAlarm");
+    this._alarmCount++;
+  },
+  onRemoveAlarmsByItem(item) {},
+  onRemoveAlarmsByCalendar(calendar) {},
+  onAlarmsLoaded(calendar) {},
+};
+alarmService.addObserver(alarmObserver);
+registerCleanupFunction(async () => {
+  alarmService.removeObserver(alarmObserver);
+});
+
+/**
+ * Tests the creation, firing, dismissal, modification and deletion of an event with an alarm.
+ * Also checks that the number of events in the unifinder is correct at each stage.
+ *
+ * Passing this test requires the active calendar to fire notifications in the correct sequence.
+ */
+async function runTestAlarms() {
+  let today = cal.dtz.now();
+  let start = today.clone();
+  start.day++;
+  start.hour = start.minute = start.second = 0;
+  let end = start.clone();
+  end.hour++;
+  let repeatUntil = start.clone();
+  repeatUntil.day += 15;
+
+  await CalendarTestUtils.setCalendarView(window, "multiweek");
+  await CalendarTestUtils.goToToday(window);
+  Assert.equal(window.unifinderTreeView.rowCount, 0, "unifinder event count");
+
+  alarmObserver._alarmCount = 0;
+
+  let alarmDialogPromise = BrowserTestUtils.promiseAlertDialog(
+    undefined,
+    "chrome://calendar/content/calendar-alarm-dialog.xhtml",
+    {
+      async callback(alarmWindow) {
+        info("Alarm dialog opened");
+        let alarmDocument = alarmWindow.document;
+
+        let list = alarmDocument.getElementById("alarm-richlist");
+        let items = list.querySelectorAll(`richlistitem[is="calendar-alarm-widget-richlistitem"]`);
+        await TestUtils.waitForCondition(() => items.length);
+        Assert.equal(items.length, 1);
+
+        await new Promise(resolve => alarmWindow.setTimeout(resolve, 500));
+
+        let dismissButton = alarmDocument.querySelector("#alarm-dismiss-all-button");
+        EventUtils.synthesizeMouseAtCenter(dismissButton, {}, alarmWindow);
+      },
+    }
+  );
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window);
+  await setData(dialogWindow, iframeWindow, {
+    title: "test event",
+    startdate: start,
+    starttime: start,
+    enddate: end,
+    endtime: end,
+    reminder: "2days",
+    repeat: "weekly",
+  });
+
+  await saveAndCloseItemDialog(dialogWindow);
+  await alarmDialogPromise;
+  info("Alarm dialog closed");
+
+  await new Promise(r => setTimeout(r, 2000));
+  Assert.equal(window.unifinderTreeView.rowCount, 1, "there should be one event in the unifinder");
+
+  Assert.equal(
+    [...Services.wm.getEnumerator("Calendar:AlarmWindow")].length,
+    0,
+    "alarm dialog did not reappear"
+  );
+  Assert.equal(alarmObserver._alarmCount, 1, "only one alarm");
+  alarmObserver._alarmCount = 0;
+
+  let eventBox = await CalendarTestUtils.multiweekView.waitForItemAt(
+    window,
+    start.weekday == 0 ? 2 : 1, // Sunday's event is next week.
+    start.weekday + 1,
+    1
+  );
+  Assert.ok(!!eventBox.item.parentItem.alarmLastAck);
+
+  ({ dialogWindow, iframeWindow } = await CalendarTestUtils.editItemOccurrences(window, eventBox));
+  await setData(dialogWindow, iframeWindow, {
+    title: "modified test event",
+    repeat: "weekly",
+    repeatuntil: repeatUntil,
+  });
+
+  await saveAndCloseItemDialog(dialogWindow);
+
+  Assert.equal(window.unifinderTreeView.rowCount, 1, "there should be one event in the unifinder");
+
+  Services.focus.focusedWindow = window;
+
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  Assert.equal(
+    [...Services.wm.getEnumerator("Calendar:AlarmWindow")].length,
+    0,
+    "alarm dialog should not reappear"
+  );
+  Assert.equal(alarmObserver._alarmCount, 0, "there should not be any remaining alarms");
+  alarmObserver._alarmCount = 0;
+
+  eventBox = await CalendarTestUtils.multiweekView.waitForItemAt(
+    window,
+    start.weekday == 0 ? 2 : 1, // Sunday's event is next week.
+    start.weekday + 1,
+    1
+  );
+  Assert.ok(!!eventBox.item.parentItem.alarmLastAck);
+
+  EventUtils.synthesizeMouseAtCenter(eventBox, {}, window);
+  eventBox.focus();
+  window.calendarController.onSelectionChanged({ detail: window.currentView().getSelectedItems() });
+  await handleDeleteOccurrencePrompt(window, window.currentView(), true);
+
+  await CalendarTestUtils.multiweekView.waitForNoItemAt(
+    window,
+    start.weekday == 0 ? 2 : 1, // Sunday's event is next week.
+    start.weekday + 1,
+    1
+  );
+  Assert.equal(window.unifinderTreeView.rowCount, 0, "there should be no events in the unifinder");
+}
+
+const syncItem1Name = "holy cow, a new item!";
+const syncItem2Name = "a changed item";
+
+let syncChangesTest = {
+  async setUp() {
+    await CalendarTestUtils.openCalendarTab(window);
+
+    if (document.getElementById("today-pane-panel").collapsed) {
+      EventUtils.synthesizeMouseAtCenter(
+        document.getElementById("calendar-status-todaypane-button"),
+        {}
+      );
+    }
+
+    if (document.getElementById("agenda-panel").collapsed) {
+      EventUtils.synthesizeMouseAtCenter(document.getElementById("today-pane-cycler-next"), {});
+    }
+  },
+
+  get part1Item() {
+    let today = cal.dtz.now();
+    let start = today.clone();
+    start.day += 9 - start.weekday;
+    start.hour = 13;
+    start.minute = start.second = 0;
+    let end = start.clone();
+    end.hour++;
+
+    return CalendarTestUtils.dedent`
+      BEGIN:VCALENDAR
+      BEGIN:VEVENT
+      UID:ad0850e5-8020-4599-86a4-86c90af4e2cd
+      SUMMARY:${syncItem1Name}
+      DTSTART:${start.icalString}
+      DTEND:${end.icalString}
+      END:VEVENT
+      END:VCALENDAR
+      `;
+  },
+
+  async runPart1() {
+    await CalendarTestUtils.setCalendarView(window, "multiweek");
+    await CalendarTestUtils.goToToday(window);
+
+    // Sanity check that we have not already synchronized and that there is no
+    // existing item.
+    Assert.ok(
+      !CalendarTestUtils.multiweekView.getItemAt(window, 2, 3, 1),
+      "there should be no existing item in the calendar"
+    );
+
+    // Synchronize.
+    EventUtils.synthesizeMouseAtCenter(document.getElementById("refreshCalendar"), {});
+
+    // Verify that the item we added appears in the calendar view.
+    let item = await CalendarTestUtils.multiweekView.waitForItemAt(window, 2, 3, 1);
+    Assert.equal(item.item.title, syncItem1Name, "view should include newly-added item");
+
+    // Verify that the today pane updates and shows the item we added.
+    await TestUtils.waitForCondition(() => window.TodayPane.agenda.rowCount == 1);
+    Assert.equal(
+      getTodayPaneItemTitle(0),
+      syncItem1Name,
+      "today pane should include newly-added item"
+    );
+    Assert.ok(
+      !window.TodayPane.agenda.rows[0].nextElementSibling,
+      "there should be no additional items in the today pane"
+    );
+  },
+
+  get part2Item() {
+    let today = cal.dtz.now();
+    let start = today.clone();
+    start.day += 10 - start.weekday;
+    start.hour = 9;
+    start.minute = start.second = 0;
+    let end = start.clone();
+    end.hour++;
+
+    return CalendarTestUtils.dedent`
+      BEGIN:VCALENDAR
+      BEGIN:VEVENT
+      UID:ad0850e5-8020-4599-86a4-86c90af4e2cd
+      SUMMARY:${syncItem2Name}
+      DTSTART:${start.icalString}
+      DTEND:${end.icalString}
+      END:VEVENT
+      END:VCALENDAR
+      `;
+  },
+
+  async runPart2() {
+    // Sanity check that we have not already synchronized and that there is no
+    // existing item.
+    Assert.ok(
+      !CalendarTestUtils.multiweekView.getItemAt(window, 2, 4, 1),
+      "there should be no existing item on the specified day"
+    );
+
+    // Synchronize.
+    EventUtils.synthesizeMouseAtCenter(document.getElementById("refreshCalendar"), {});
+
+    // Verify that the item has updated in the calendar view.
+    await CalendarTestUtils.multiweekView.waitForNoItemAt(window, 2, 3, 1);
+    let item = await CalendarTestUtils.multiweekView.waitForItemAt(window, 2, 4, 1);
+    Assert.equal(item.item.title, syncItem2Name, "view should show updated item");
+
+    // Verify that the today pane updates and shows the updated item.
+    await TestUtils.waitForCondition(
+      () => window.TodayPane.agenda.rowCount == 1 && getTodayPaneItemTitle(0) != syncItem1Name
+    );
+    Assert.equal(getTodayPaneItemTitle(0), syncItem2Name, "today pane should show updated item");
+    Assert.ok(
+      !window.TodayPane.agenda.rows[0].nextElementSibling,
+      "there should be no additional items in the today pane"
+    );
+  },
+
+  async runPart3() {
+    // Synchronize via the calendar context menu.
+    await calendarListContextMenu(
+      document.querySelector("#calendar-list > li:nth-child(2)"),
+      "list-calendar-context-reload"
+    );
+
+    // Verify that the item is removed from the calendar view.
+    await CalendarTestUtils.multiweekView.waitForNoItemAt(window, 2, 3, 1);
+    await CalendarTestUtils.multiweekView.waitForNoItemAt(window, 2, 4, 1);
+
+    // Verify that the item is removed from the today pane.
+    await TestUtils.waitForCondition(() => window.TodayPane.agenda.rowCount == 0);
+  },
+};
+
+function getTodayPaneItemTitle(idx) {
+  const row = window.TodayPane.agenda.rows[idx];
+  return row.querySelector(".agenda-listitem-title").textContent;
+}
+
+async function calendarListContextMenu(target, menuItem) {
+  await new Promise(r => setTimeout(r));
+  window.focus();
+  await TestUtils.waitForCondition(
+    () => Services.focus.focusedWindow == window,
+    "waiting for window to be focused"
+  );
+
+  let contextMenu = document.getElementById("list-calendars-context-menu");
+  let shownPromise = BrowserTestUtils.waitForEvent(contextMenu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(target, { type: "contextmenu" });
+  await shownPromise;
+
+  if (menuItem) {
+    let hiddenPromise = BrowserTestUtils.waitForEvent(contextMenu, "popuphidden");
+    contextMenu.activateItem(document.getElementById(menuItem));
+    await hiddenPromise;
+  }
+}
diff --git a/comm/calendar/test/browser/recurrence/browser.ini b/comm/calendar/test/browser/recurrence/browser.ini
new file mode 100644
index 0000000000..633ed27dde
--- /dev/null
+++ b/comm/calendar/test/browser/recurrence/browser.ini
@@ -0,0 +1,23 @@
+[default]
+dupe-manifest =
+prefs =
+  calendar.item.promptDelete=false
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+  calendar.week.start=0
+  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
+tags = recurrence
+
+[browser_annual.js]
+[browser_biweekly.js]
+[browser_daily.js]
+[browser_lastDayOfMonth.js]
+[browser_recurrenceNavigation.js]
+[browser_weeklyN.js]
+[browser_weeklyUntil.js]
+[browser_weeklyWithException.js]
diff --git a/comm/calendar/test/browser/recurrence/browser_annual.js b/comm/calendar/test/browser/recurrence/browser_annual.js
new file mode 100644
index 0000000000..54c7198f05
--- /dev/null
+++ b/comm/calendar/test/browser/recurrence/browser_annual.js
@@ -0,0 +1,69 @@
+/* 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 { handleDeleteOccurrencePrompt } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarUtils.jsm"
+);
+
+var { saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { dayView, weekView, multiweekView, monthView } = CalendarTestUtils;
+
+const STARTYEAR = 1950;
+const EPOCH = 1970;
+
+add_task(async function testAnnualRecurrence() {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, STARTYEAR, 1, 1);
+
+  // Create yearly recurring all-day event.
+  let eventBox = dayView.getAllDayHeader(window);
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, eventBox);
+  await setData(dialogWindow, iframeWindow, { title: "Event", repeat: "yearly" });
+  await saveAndCloseItemDialog(dialogWindow);
+  await TestUtils.waitForCondition(
+    () => CalendarTestUtils.dayView.getAllDayItemAt(window, 1),
+    "recurring all-day event created"
+  );
+
+  let checkYears = [STARTYEAR, STARTYEAR + 1, EPOCH - 1, EPOCH, EPOCH + 1];
+  for (let year of checkYears) {
+    await CalendarTestUtils.goToDate(window, year, 1, 1);
+    let date = new Date(Date.UTC(year, 0, 1));
+    let column = date.getUTCDay() + 1;
+
+    // day view
+    await CalendarTestUtils.setCalendarView(window, "day");
+    await dayView.waitForAllDayItemAt(window, 1);
+
+    // week view
+    await CalendarTestUtils.setCalendarView(window, "week");
+    await weekView.waitForAllDayItemAt(window, column, 1);
+
+    // multiweek view
+    await CalendarTestUtils.setCalendarView(window, "multiweek");
+    await multiweekView.waitForItemAt(window, 1, column, 1);
+
+    // month view
+    await CalendarTestUtils.setCalendarView(window, "month");
+    await monthView.waitForItemAt(window, 1, column, 1);
+  }
+
+  // Delete event.
+  await CalendarTestUtils.goToDate(window, checkYears[0], 1, 1);
+  await CalendarTestUtils.setCalendarView(window, "day");
+  const box = await dayView.waitForAllDayItemAt(window, 1);
+  EventUtils.synthesizeMouseAtCenter(box, {}, window);
+  await handleDeleteOccurrencePrompt(window, box, true);
+  await TestUtils.waitForCondition(() => !dayView.getAllDayItemAt(window, 1), "No all-day events");
+
+  Assert.ok(true, "Test ran to completion");
+});
diff --git a/comm/calendar/test/browser/recurrence/browser_biweekly.js b/comm/calendar/test/browser/recurrence/browser_biweekly.js
new file mode 100644
index 0000000000..6889822375
--- /dev/null
+++ b/comm/calendar/test/browser/recurrence/browser_biweekly.js
@@ -0,0 +1,85 @@
+/* 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 { handleDeleteOccurrencePrompt } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarUtils.jsm"
+);
+
+var { saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { dayView, weekView, multiweekView, monthView } = CalendarTestUtils;
+
+const HOUR = 8;
+
+add_task(async function testBiweeklyRecurrence() {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 31);
+
+  // Create biweekly event.
+  let eventBox = dayView.getHourBoxAt(window, HOUR);
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, eventBox);
+  await setData(dialogWindow, iframeWindow, { title: "Event", repeat: "bi.weekly" });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Check day view.
+  await CalendarTestUtils.setCalendarView(window, "day");
+  for (let i = 0; i < 4; i++) {
+    await dayView.waitForEventBoxAt(window, 1);
+    await CalendarTestUtils.calendarViewForward(window, 14);
+  }
+
+  // Check week view.
+  await CalendarTestUtils.setCalendarView(window, "week");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 31);
+
+  for (let i = 0; i < 4; i++) {
+    await weekView.waitForEventBoxAt(window, 7, 1);
+    await CalendarTestUtils.calendarViewForward(window, 2);
+  }
+
+  // Check multiweek view.
+  await CalendarTestUtils.setCalendarView(window, "multiweek");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 31);
+
+  // Always two occurrences in view, 1st and 3rd or 2nd and 4th week.
+  for (let i = 0; i < 5; i++) {
+    await multiweekView.waitForItemAt(window, (i % 2) + 1, 7, 1);
+    Assert.ok(multiweekView.getItemAt(window, (i % 2) + 3, 7, 1));
+    await CalendarTestUtils.calendarViewForward(window, 1);
+  }
+
+  // Check month view.
+  await CalendarTestUtils.setCalendarView(window, "month");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 31);
+
+  // January
+  await monthView.waitForItemAt(window, 5, 7, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+
+  // February
+  await monthView.waitForItemAt(window, 2, 7, 1);
+  Assert.ok(monthView.getItemAt(window, 4, 7, 1));
+  await CalendarTestUtils.calendarViewForward(window, 1);
+
+  // March
+  await monthView.waitForItemAt(window, 2, 7, 1);
+
+  let box = monthView.getItemAt(window, 4, 7, 1);
+  Assert.ok(box);
+
+  // Delete event.
+  EventUtils.synthesizeMouseAtCenter(box, {}, window);
+  await handleDeleteOccurrencePrompt(window, box, true);
+
+  await monthView.waitForNoItemAt(window, 4, 7, 1);
+
+  Assert.ok(true, "Test ran to completion");
+});
diff --git a/comm/calendar/test/browser/recurrence/browser_daily.js b/comm/calendar/test/browser/recurrence/browser_daily.js
new file mode 100644
index 0000000000..42ffc4c8db
--- /dev/null
+++ b/comm/calendar/test/browser/recurrence/browser_daily.js
@@ -0,0 +1,162 @@
+/* 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 { handleDeleteOccurrencePrompt } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarUtils.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var {
+  calendarViewBackward,
+  calendarViewForward,
+  setCalendarView,
+  dayView,
+  weekView,
+  multiweekView,
+  monthView,
+} = CalendarTestUtils;
+
+const HOUR = 8;
+const TITLE = "Event";
+
+add_task(async function testDailyRecurrence() {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  // Create daily event.
+  let eventBox = dayView.getHourBoxAt(window, HOUR);
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, eventBox);
+  await setData(dialogWindow, iframeWindow, {
+    title: TITLE,
+    repeat: "daily",
+    repeatuntil: cal.createDateTime("20090320T000000Z"),
+  });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Check day view for 7 days.
+  for (let day = 1; day <= 7; day++) {
+    await dayView.waitForEventBoxAt(window, 1);
+    await calendarViewForward(window, 1);
+  }
+
+  // Check week view for 2 weeks.
+  await setCalendarView(window, "week");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  for (let day = 5; day <= 7; day++) {
+    await weekView.waitForEventBoxAt(window, day, 1);
+  }
+
+  await calendarViewForward(window, 1);
+
+  for (let day = 1; day <= 7; day++) {
+    await weekView.waitForEventBoxAt(window, day, 1);
+  }
+
+  // Check multiweek view for 4 weeks.
+  await setCalendarView(window, "multiweek");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  for (let day = 5; day <= 7; day++) {
+    await multiweekView.waitForItemAt(window, 1, day, 1);
+  }
+
+  for (let week = 2; week <= 4; week++) {
+    for (let day = 1; day <= 7; day++) {
+      await multiweekView.waitForItemAt(window, week, day, 1);
+    }
+  }
+  // Check month view for all 5 weeks.
+  await setCalendarView(window, "month");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  for (let day = 5; day <= 7; day++) {
+    await monthView.waitForItemAt(window, 1, day, 1);
+  }
+
+  for (let week = 2; week <= 5; week++) {
+    for (let day = 1; day <= 7; day++) {
+      await monthView.waitForItemAt(window, week, day, 1);
+    }
+  }
+
+  // Delete 3rd January occurrence.
+  let saturday = await monthView.waitForItemAt(window, 1, 7, 1);
+  EventUtils.synthesizeMouseAtCenter(saturday, {}, window);
+  await handleDeleteOccurrencePrompt(window, saturday, false);
+
+  // Verify in all views.
+  await monthView.waitForNoItemAt(window, 1, 7, 1);
+
+  await setCalendarView(window, "multiweek");
+  Assert.ok(!multiweekView.getItemAt(window, 1, 7, 1));
+
+  await setCalendarView(window, "week");
+  Assert.ok(!weekView.getEventBoxAt(window, 7, 1));
+
+  await setCalendarView(window, "day");
+  Assert.ok(!dayView.getEventBoxAt(window, 1));
+
+  // Go to previous day to edit event to occur only on weekdays.
+  await calendarViewBackward(window, 1);
+
+  ({ dialogWindow, iframeWindow } = await dayView.editEventOccurrencesAt(window, 1));
+  await setData(dialogWindow, iframeWindow, { repeat: "every.weekday" });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Check day view for 7 days.
+  let dates = [
+    [2009, 1, 3],
+    [2009, 1, 4],
+  ];
+  for (let [y, m, d] of dates) {
+    await CalendarTestUtils.goToDate(window, y, m, d);
+    Assert.ok(!dayView.getEventBoxAt(window, 1));
+  }
+
+  // Check week view for 2 weeks.
+  await setCalendarView(window, "week");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  for (let i = 0; i <= 1; i++) {
+    await weekView.waitForNoEventBoxAt(window, 1, 1);
+    Assert.ok(!weekView.getEventBoxAt(window, 7, 1));
+    await calendarViewForward(window, 1);
+  }
+
+  // Check multiweek view for 4 weeks.
+  await setCalendarView(window, "multiweek");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  for (let i = 1; i <= 4; i++) {
+    await multiweekView.waitForNoItemAt(window, i, 1, 1);
+    Assert.ok(!multiweekView.getItemAt(window, i, 7, 1));
+  }
+
+  // Check month view for all 5 weeks.
+  await setCalendarView(window, "month");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  for (let i = 1; i <= 5; i++) {
+    await monthView.waitForNoItemAt(window, i, 1, 1);
+    Assert.ok(!monthView.getItemAt(window, i, 7, 1));
+  }
+
+  // Delete event.
+  let day = monthView.getItemAt(window, 1, 5, 1);
+  EventUtils.synthesizeMouseAtCenter(day, {}, window);
+  await handleDeleteOccurrencePrompt(window, day, true);
+  await monthView.waitForNoItemAt(window, 1, 5, 1);
+
+  Assert.ok(true, "Test ran to completion");
+});
diff --git a/comm/calendar/test/browser/recurrence/browser_lastDayOfMonth.js b/comm/calendar/test/browser/recurrence/browser_lastDayOfMonth.js
new file mode 100644
index 0000000000..bc7e01556a
--- /dev/null
+++ b/comm/calendar/test/browser/recurrence/browser_lastDayOfMonth.js
@@ -0,0 +1,112 @@
+/* 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 { handleDeleteOccurrencePrompt } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarUtils.jsm"
+);
+
+var { menulistSelect } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+var { saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { setCalendarView, dayView, weekView, multiweekView, monthView } = CalendarTestUtils;
+
+const HOUR = 8;
+
+add_task(async function testLastDayOfMonthRecurrence() {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2008, 1, 31); // Start with a leap year.
+
+  // Create monthly recurring event.
+  let eventBox = dayView.getHourBoxAt(window, HOUR);
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, eventBox);
+  await setData(dialogWindow, iframeWindow, { title: "Event", repeat: setRecurrence });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // data tuple: [year, month, day, row in month view]
+  // note: Month starts here with 1 for January.
+  let checkingData = [
+    [2008, 1, 31, 5],
+    [2008, 2, 29, 5],
+    [2008, 3, 31, 6],
+    [2008, 4, 30, 5],
+    [2008, 5, 31, 5],
+    [2008, 6, 30, 5],
+    [2008, 7, 31, 5],
+    [2008, 8, 31, 6],
+    [2008, 9, 30, 5],
+    [2008, 10, 31, 5],
+    [2008, 11, 30, 6],
+    [2008, 12, 31, 5],
+    [2009, 1, 31, 5],
+    [2009, 2, 28, 4],
+    [2009, 3, 31, 5],
+  ];
+  // Check all dates.
+  for (let [y, m, d, correctRow] of checkingData) {
+    let date = new Date(Date.UTC(y, m - 1, d));
+    let column = date.getUTCDay() + 1;
+
+    await CalendarTestUtils.goToDate(window, y, m, d);
+
+    // day view
+    await setCalendarView(window, "day");
+    await dayView.waitForEventBoxAt(window, 1);
+
+    // week view
+    await setCalendarView(window, "week");
+    await weekView.waitForEventBoxAt(window, column, 1);
+
+    // multiweek view
+    await setCalendarView(window, "multiweek");
+    await multiweekView.waitForItemAt(window, 1, column, 1);
+
+    // month view
+    await setCalendarView(window, "month");
+    await monthView.waitForItemAt(window, correctRow, column, 1);
+  }
+
+  // Delete event.
+  await CalendarTestUtils.goToDate(
+    window,
+    checkingData[0][0],
+    checkingData[0][1],
+    checkingData[0][2]
+  );
+  await setCalendarView(window, "day");
+  let box = await dayView.waitForEventBoxAt(window, 1);
+  EventUtils.synthesizeMouseAtCenter(box, {}, window);
+  await handleDeleteOccurrencePrompt(window, box, true);
+  await dayView.waitForNoEventBoxAt(window, 1);
+
+  Assert.ok(true, "Test ran to completion");
+});
+
+async function setRecurrence(recurrenceWindow) {
+  let recurrenceDocument = recurrenceWindow.document;
+  // monthly
+  await menulistSelect(recurrenceDocument.getElementById("period-list"), "2");
+
+  // last day of month
+  EventUtils.synthesizeMouseAtCenter(
+    recurrenceDocument.getElementById("montly-period-relative-date-radio"),
+    {},
+    recurrenceWindow
+  );
+  await menulistSelect(recurrenceDocument.getElementById("monthly-ordinal"), "-1");
+  await menulistSelect(recurrenceDocument.getElementById("monthly-weekday"), "-1");
+
+  let button = recurrenceDocument.querySelector("dialog").getButton("accept");
+  button.scrollIntoView();
+  // Close dialog.
+  EventUtils.synthesizeMouseAtCenter(button, {}, recurrenceWindow);
+}
diff --git a/comm/calendar/test/browser/recurrence/browser_recurrenceNavigation.js b/comm/calendar/test/browser/recurrence/browser_recurrenceNavigation.js
new file mode 100644
index 0000000000..8dfe7287ce
--- /dev/null
+++ b/comm/calendar/test/browser/recurrence/browser_recurrenceNavigation.js
@@ -0,0 +1,138 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+const calendar = CalendarTestUtils.createCalendar("Minimonths", "memory");
+
+registerCleanupFunction(() => {
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+add_task(async function testRecurrenceNavigation() {
+  await CalendarTestUtils.setCalendarView(window, "month");
+
+  let eventDate = cal.createDateTime("20200201T000001Z");
+  window.goToDate(eventDate);
+
+  let newEventBtn = document.querySelector("#sidePanelNewEvent");
+  let getEventWin = CalendarTestUtils.waitForEventDialog("edit");
+  EventUtils.synthesizeMouseAtCenter(newEventBtn, {});
+
+  let eventWin = await getEventWin;
+  let iframe = eventWin.document.querySelector("iframe");
+
+  let getRepeatWin = BrowserTestUtils.promiseAlertDialogOpen(
+    "",
+    "chrome://calendar/content/calendar-event-dialog-recurrence.xhtml",
+    {
+      async callback(win) {
+        let container = await TestUtils.waitForCondition(() => {
+          return win.document.querySelector("#recurrencePreviewContainer");
+        }, `The recurrence container exists`);
+
+        let initialMonth = await TestUtils.waitForCondition(() => {
+          return container.querySelector(`calendar-minimonth[month="1"][year="2020"]`);
+        }, `Initial month exists`);
+        Assert.ok(!initialMonth.hidden, `Initial month is visible on load`);
+
+        let nextButton = container.querySelector("#recurrenceNext");
+        Assert.ok(nextButton, `Next button exists`);
+        nextButton.scrollIntoView();
+        EventUtils.synthesizeMouseAtCenter(nextButton, {}, win);
+
+        let nextMonth = container.querySelector(`calendar-minimonth[month="2"][year="2020"]`);
+        Assert.ok(nextMonth, `Next month exists`);
+        Assert.ok(!nextMonth.hidden, `Next month is visible`);
+
+        let previousButton = container.querySelector("#recurrencePrevious");
+        Assert.ok(previousButton, `Previous button exists`);
+        previousButton.scrollIntoView();
+        EventUtils.synthesizeMouseAtCenter(previousButton, {}, win);
+        Assert.ok(!initialMonth.hidden, `Previous month is visible after using previous button`);
+
+        // Check that future dates display
+        nextButton.scrollIntoView();
+        for (let index = 0; index < 5; index++) {
+          EventUtils.synthesizeMouseAtCenter(nextButton, {}, win);
+        }
+
+        let futureMonth = await TestUtils.waitForCondition(() => {
+          return container.querySelector(`calendar-minimonth[month="6"][year="2020"]`);
+        }, `Future month exist`);
+        Assert.ok(!futureMonth.hidden, `Future month is visible after using next button`);
+
+        // Ensure the number of minimonths shown is the amount we expect.
+        let defaultMinimonthCount = "3";
+        let actualVisibleMinimonthCount = container.querySelectorAll(
+          `calendar-minimonth:not([hidden])`
+        ).length;
+        Assert.equal(
+          defaultMinimonthCount,
+          actualVisibleMinimonthCount,
+          `Default minimonth visible count matches actual: ${actualVisibleMinimonthCount}`
+        );
+
+        // Go back 5 times; we should go back to the initial month.
+        for (let index = 0; index < 5; index++) {
+          EventUtils.synthesizeMouseAtCenter(previousButton, {}, win);
+        }
+        Assert.ok(!initialMonth.hidden, `Initial month is visible`);
+
+        // Close window at end of tests for this item
+        await BrowserTestUtils.closeWindow(win);
+      },
+    }
+  );
+
+  let repeatMenu = iframe.contentDocument.querySelector("#item-repeat");
+  repeatMenu.value = "custom";
+  repeatMenu.doCommand();
+  await getRepeatWin;
+
+  await BrowserTestUtils.closeWindow(eventWin);
+});
+
+add_task(async function testRecurrenceCreationOfMonths() {
+  await CalendarTestUtils.setCalendarView(window, "month");
+
+  let eventDate = cal.createDateTime("20200101T000001Z");
+  window.goToDate(eventDate);
+
+  let newEventBtn = document.querySelector("#sidePanelNewEvent");
+  let getEventWin = CalendarTestUtils.waitForEventDialog("edit");
+  EventUtils.synthesizeMouseAtCenter(newEventBtn, {});
+
+  let eventWin = await getEventWin;
+  let iframe = eventWin.document.querySelector("iframe");
+
+  let getRepeatWin = BrowserTestUtils.promiseAlertDialogOpen(
+    "",
+    "chrome://calendar/content/calendar-event-dialog-recurrence.xhtml",
+    {
+      async callback(win) {
+        let container = win.document.querySelector("#recurrencePreviewContainer");
+        let nextButton = container.querySelector("#recurrenceNext");
+        nextButton.scrollIntoView();
+        for (let index = 0; index < 10; index++) {
+          EventUtils.synthesizeMouseAtCenter(nextButton, {}, win);
+        }
+
+        let futureMonth = container.querySelector(`calendar-minimonth[month="10"][year="2020"]`);
+        Assert.ok(futureMonth, `Dynamically created future month exists`);
+        Assert.ok(!futureMonth.hidden, `Dynamically created future month is visible`);
+
+        // Close window at end of tests for this item
+        await BrowserTestUtils.closeWindow(win);
+      },
+    }
+  );
+
+  let repeatMenu = iframe.contentDocument.querySelector("#item-repeat");
+  repeatMenu.value = "custom";
+  repeatMenu.doCommand();
+  await getRepeatWin;
+
+  await BrowserTestUtils.closeWindow(eventWin);
+});
diff --git a/comm/calendar/test/browser/recurrence/browser_rotated.ini b/comm/calendar/test/browser/recurrence/browser_rotated.ini
new file mode 100644
index 0000000000..2385ed9324
--- /dev/null
+++ b/comm/calendar/test/browser/recurrence/browser_rotated.ini
@@ -0,0 +1,24 @@
+[default]
+head = head.js
+dupe-manifest =
+prefs =
+  calendar.item.promptDelete=false
+  calendar.test.rotateViews=true
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+  calendar.week.start=0
+  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
+tags = recurrence-rotated
+
+[browser_annual.js]
+[browser_biweekly.js]
+[browser_daily.js]
+[browser_lastDayOfMonth.js]
+[browser_weeklyN.js]
+[browser_weeklyUntil.js]
+[browser_weeklyWithException.js]
diff --git a/comm/calendar/test/browser/recurrence/browser_weeklyN.js b/comm/calendar/test/browser/recurrence/browser_weeklyN.js
new file mode 100644
index 0000000000..e32ab470f1
--- /dev/null
+++ b/comm/calendar/test/browser/recurrence/browser_weeklyN.js
@@ -0,0 +1,268 @@
+/* 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 { handleDeleteOccurrencePrompt } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarUtils.jsm"
+);
+
+var { menulistSelect, saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+var { dayView, weekView, multiweekView, monthView } = CalendarTestUtils;
+
+const HOUR = 8;
+
+/*
+ * This test is intended to verify that events recurring on a weekly basis are
+ * correctly created and displayed. The event should recur on multiple days in
+ * the week, skip days, and be limited to a certain number of recurrences in
+ * order to verify that these parameters are respected. Deletion should delete
+ * all event occurrences when appropriate.
+ */
+add_task(async function testWeeklyNRecurrence() {
+  async function setRecurrence(recurrenceWindow) {
+    let recurrenceDocument = recurrenceWindow.document;
+
+    // Select weekly recurrence
+    await menulistSelect(recurrenceDocument.getElementById("period-list"), "1");
+
+    let monLabel = cal.l10n.getDateFmtString("day.2.Mmm");
+    let tueLabel = cal.l10n.getDateFmtString("day.3.Mmm");
+    let wedLabel = cal.l10n.getDateFmtString("day.4.Mmm");
+    let friLabel = cal.l10n.getDateFmtString("day.6.Mmm");
+    let satLabel = cal.l10n.getDateFmtString("day.7.Mmm");
+
+    let dayPicker = recurrenceDocument.getElementById("daypicker-weekday");
+
+    // Selected date is a Monday, so it should already be selected
+    Assert.ok(
+      dayPicker.querySelector(`[label="${monLabel}"]`).checked,
+      "Monday should already be selected"
+    );
+
+    // Select Tuesday, Wednesday, Friday, and Saturday as additional days for
+    // event occurrences
+    EventUtils.synthesizeMouseAtCenter(
+      dayPicker.querySelector(`[label="${tueLabel}"]`),
+      {},
+      recurrenceWindow
+    );
+    EventUtils.synthesizeMouseAtCenter(
+      dayPicker.querySelector(`[label="${wedLabel}"]`),
+      {},
+      recurrenceWindow
+    );
+    EventUtils.synthesizeMouseAtCenter(
+      dayPicker.querySelector(`[label="${friLabel}"]`),
+      {},
+      recurrenceWindow
+    );
+    EventUtils.synthesizeMouseAtCenter(
+      dayPicker.querySelector(`[label="${satLabel}"]`),
+      {},
+      recurrenceWindow
+    );
+
+    // Create a total of four events
+    EventUtils.synthesizeMouseAtCenter(
+      recurrenceDocument.getElementById("recurrence-range-for"),
+      {},
+      recurrenceWindow
+    );
+    recurrenceDocument.getElementById("repeat-ntimes-count").value = "4";
+
+    let button = recurrenceDocument.querySelector("dialog").getButton("accept");
+    button.scrollIntoView();
+    // Close dialog
+    EventUtils.synthesizeMouseAtCenter(button, {}, recurrenceWindow);
+  }
+
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 5);
+
+  // Create event recurring on a weekly basis
+  let eventBox = dayView.getHourBoxAt(window, HOUR);
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, eventBox);
+  await setData(dialogWindow, iframeWindow, { title: "Event", repeat: setRecurrence });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Verify in the day view that events were created for Monday through Wednesday
+  for (let i = 0; i < 3; i++) {
+    await dayView.waitForEventBoxAt(window, 1);
+    await CalendarTestUtils.calendarViewForward(window, 1);
+  }
+
+  // No event should have been created on Thursday because it was not selected
+  await dayView.waitForNoEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+
+  // An event should have been created for Friday because it was selected
+  await dayView.waitForEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+
+  // No event should have been created on Saturday due to four event limit
+  await dayView.waitForNoEventBoxAt(window, 1);
+
+  // Validate event creation and lack of Saturday event in week view
+  await CalendarTestUtils.setCalendarView(window, "week");
+
+  for (let i = 2; i < 5; i++) {
+    await weekView.waitForEventBoxAt(window, i, 1);
+  }
+
+  // No event Thursday or Saturday, event on Friday
+  await weekView.waitForNoEventBoxAt(window, 5, 1);
+  await weekView.waitForEventBoxAt(window, 6, 1);
+  await weekView.waitForNoEventBoxAt(window, 7, 1);
+
+  // Validate event creation and lack of Saturday event in multiweek view
+  await CalendarTestUtils.setCalendarView(window, "multiweek");
+
+  for (let i = 2; i < 5; i++) {
+    await multiweekView.waitForItemAt(window, 1, i, 1);
+  }
+
+  // No event Thursday or Saturday, event on Friday
+  await multiweekView.waitForNoItemAt(window, 1, 5, 1);
+  await multiweekView.waitForItemAt(window, 1, 6, 1);
+  await multiweekView.waitForNoItemAt(window, 1, 7, 1);
+
+  // Validate event creation and lack of Saturday event in month view
+  await CalendarTestUtils.setCalendarView(window, "month");
+
+  for (let i = 2; i < 5; i++) {
+    // This should be the second week in the month
+    await monthView.waitForItemAt(window, 2, i, 1);
+  }
+
+  // No event Thursday or Saturday, event on Friday
+  await monthView.waitForNoItemAt(window, 2, 5, 1);
+  await monthView.waitForItemAt(window, 2, 6, 1);
+  await monthView.waitForNoItemAt(window, 2, 7, 1);
+
+  // Delete event
+  let box = await monthView.waitForItemAt(window, 2, 2, 1);
+  EventUtils.synthesizeMouseAtCenter(box, {}, window);
+  await handleDeleteOccurrencePrompt(window, box, true);
+
+  // All occurrences should have been deleted
+  for (let i = 2; i < 5; i++) {
+    await monthView.waitForNoItemAt(window, 2, i, 1);
+  }
+
+  await monthView.waitForNoItemAt(window, 2, 6, 1);
+});
+
+/*
+ * This test is intended to catch instances in which we aren't correctly setting
+ * the week start value of recurrences. For example, if the user has set their
+ * week to start on Saturday, then creates a recurring event running every other
+ * Saturday, Sunday, and Monday, they expect to see events on the initial
+ * Saturday, Sunday, Monday, skip a week, repeat. However, week start defaults
+ * to Monday, so if it is not correctly set, they would see events on the
+ * initial Saturday and Sunday, nothing on Monday, but an event on the following
+ * Monday.
+ */
+add_task(async function testRecurrenceAcrossWeekStart() {
+  // Sanity check that we're not testing against a default value
+  const initialWeekStart = Services.prefs.getIntPref("calendar.week.start", 0);
+  Assert.notEqual(initialWeekStart, 6, "week start should not be Saturday");
+
+  // Set week start to Saturday
+  Services.prefs.setIntPref("calendar.week.start", 6);
+  registerCleanupFunction(() => {
+    Services.prefs.setIntPref("calendar.week.start", initialWeekStart);
+  });
+
+  async function setRecurrence(recurrenceWindow) {
+    let recurrenceDocument = recurrenceWindow.document;
+
+    // Select weekly recurrence
+    await menulistSelect(recurrenceDocument.getElementById("period-list"), "1");
+
+    // Recur every two weeks
+    recurrenceDocument.getElementById("weekly-weeks").value = "2";
+
+    let satLabel = cal.l10n.getDateFmtString("day.7.Mmm");
+    let sunLabel = cal.l10n.getDateFmtString("day.1.Mmm");
+    let monLabel = cal.l10n.getDateFmtString("day.2.Mmm");
+
+    let dayPicker = recurrenceDocument.getElementById("daypicker-weekday");
+
+    // Selected date is a Saturday, so it should already be selected
+    Assert.ok(
+      dayPicker.querySelector(`[label="${satLabel}"]`).checked,
+      "Saturday should already be checked"
+    );
+
+    // Select Sunday and Monday as additional days for event occurrences
+    EventUtils.synthesizeMouseAtCenter(
+      dayPicker.querySelector(`[label="${sunLabel}"]`),
+      {},
+      recurrenceWindow
+    );
+    EventUtils.synthesizeMouseAtCenter(
+      dayPicker.querySelector(`[label="${monLabel}"]`),
+      {},
+      recurrenceWindow
+    );
+
+    // Create a total of six events
+    EventUtils.synthesizeMouseAtCenter(
+      recurrenceDocument.getElementById("recurrence-range-for"),
+      {},
+      recurrenceWindow
+    );
+    recurrenceDocument.getElementById("repeat-ntimes-count").value = "6";
+
+    let button = recurrenceDocument.querySelector("dialog").getButton("accept");
+    button.scrollIntoView();
+    // Close dialog
+    EventUtils.synthesizeMouseAtCenter(button, {}, recurrenceWindow);
+  }
+
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2022, 10, 15);
+
+  // Create event recurring every other week
+  let eventBox = dayView.getHourBoxAt(window, HOUR);
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, eventBox);
+  await setData(dialogWindow, iframeWindow, { title: "Event", repeat: setRecurrence });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Open week view
+  await CalendarTestUtils.setCalendarView(window, "week");
+
+  // Verify events created on Saturday, Sunday, Monday of first week
+  for (let i = 1; i < 4; i++) {
+    await weekView.waitForEventBoxAt(window, i, 1);
+  }
+
+  // Verify no events created on Saturday, Sunday, Monday of second week
+  await CalendarTestUtils.calendarViewForward(window, 1);
+
+  for (let i = 1; i < 4; i++) {
+    await weekView.waitForNoEventBoxAt(window, i, 1);
+  }
+
+  // Verify events created on Saturday, Sunday, Monday of third week
+  await CalendarTestUtils.calendarViewForward(window, 1);
+
+  for (let i = 1; i < 4; i++) {
+    await weekView.waitForEventBoxAt(window, i, 1);
+  }
+});
diff --git a/comm/calendar/test/browser/recurrence/browser_weeklyUntil.js b/comm/calendar/test/browser/recurrence/browser_weeklyUntil.js
new file mode 100644
index 0000000000..c9780e9428
--- /dev/null
+++ b/comm/calendar/test/browser/recurrence/browser_weeklyUntil.js
@@ -0,0 +1,175 @@
+/* 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 { handleDeleteOccurrencePrompt } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarUtils.jsm"
+);
+
+var { formatDate, menulistSelect, saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+var { dayView, weekView, multiweekView, monthView } = CalendarTestUtils;
+
+const ENDDATE = cal.createDateTime("20090126T000000Z"); // Last Monday in month.
+const HOUR = 8;
+
+add_task(async function testWeeklyUntilRecurrence() {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 5); // Monday
+
+  // Create weekly recurring event.
+  let eventBox = dayView.getHourBoxAt(window, HOUR);
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, eventBox);
+  await setData(dialogWindow, iframeWindow, { title: "Event", repeat: setRecurrence });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Check day view.
+  for (let week = 0; week < 3; week++) {
+    // Monday
+    await dayView.waitForEventBoxAt(window, 1);
+    await CalendarTestUtils.calendarViewForward(window, 2);
+
+    // Wednesday
+    await dayView.waitForEventBoxAt(window, 1);
+    await CalendarTestUtils.calendarViewForward(window, 2);
+
+    // Friday
+    await dayView.waitForEventBoxAt(window, 1);
+    await CalendarTestUtils.calendarViewForward(window, 3);
+  }
+
+  // Monday, last occurrence
+  await dayView.waitForEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 2);
+
+  // Wednesday
+  await dayView.waitForNoEventBoxAt(window, 1);
+
+  // Check week view.
+  await CalendarTestUtils.setCalendarView(window, "week");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 5);
+  for (let week = 0; week < 3; week++) {
+    // Monday
+    await weekView.waitForEventBoxAt(window, 2, 1);
+
+    // Wednesday
+    await weekView.waitForEventBoxAt(window, 4, 1);
+
+    // Friday
+    await weekView.waitForEventBoxAt(window, 6, 1);
+
+    await CalendarTestUtils.calendarViewForward(window, 1);
+  }
+
+  // Monday, last occurrence
+  await weekView.waitForEventBoxAt(window, 2, 1);
+  // Wednesday
+  await weekView.waitForNoEventBoxAt(window, 4, 1);
+
+  // Check multiweek view.
+  await CalendarTestUtils.setCalendarView(window, "multiweek");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 5);
+  for (let week = 1; week < 4; week++) {
+    // Monday
+    await multiweekView.waitForItemAt(window, week, 2, 1);
+    // Wednesday
+    await multiweekView.waitForItemAt(window, week, 4, 1);
+    // Friday
+    await multiweekView.waitForItemAt(window, week, 6, 1);
+  }
+
+  // Monday, last occurrence
+  await multiweekView.waitForItemAt(window, 4, 2, 1);
+
+  // Wednesday
+  await multiweekView.waitForNoItemAt(window, 4, 4, 1);
+
+  // Check month view.
+  await CalendarTestUtils.setCalendarView(window, "month");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 5);
+  // starts on week 2 in month-view
+  for (let week = 2; week < 5; week++) {
+    // Monday
+    await monthView.waitForItemAt(window, week, 2, 1);
+    // Wednesday
+    await monthView.waitForItemAt(window, week, 4, 1);
+    // Friday
+    await monthView.waitForItemAt(window, week, 6, 1);
+  }
+
+  // Monday, last occurrence
+  await monthView.waitForItemAt(window, 5, 2, 1);
+
+  // Wednesday
+  await monthView.waitForNoItemAt(window, 5, 4, 1);
+
+  // Delete event.
+  let box = monthView.getItemAt(window, 2, 2, 1);
+  EventUtils.synthesizeMouseAtCenter(box, {}, window);
+  await handleDeleteOccurrencePrompt(window, box, true);
+  await monthView.waitForNoItemAt(window, 2, 2, 1);
+
+  Assert.ok(true, "Test ran to completion");
+});
+
+async function setRecurrence(recurrenceWindow) {
+  let recurrenceDocument = recurrenceWindow.document;
+
+  // weekly
+  await menulistSelect(recurrenceDocument.getElementById("period-list"), "1");
+
+  let mon = cal.l10n.getDateFmtString("day.2.Mmm");
+  let wed = cal.l10n.getDateFmtString("day.4.Mmm");
+  let fri = cal.l10n.getDateFmtString("day.6.Mmm");
+
+  let dayPicker = recurrenceDocument.getElementById("daypicker-weekday");
+
+  // Starting from Monday so it should be checked.
+  Assert.ok(dayPicker.querySelector(`[label="${mon}"]`).checked, "mon checked");
+  // Check Wednesday and Friday too.
+  EventUtils.synthesizeMouseAtCenter(
+    dayPicker.querySelector(`[label="${wed}"]`),
+    {},
+    recurrenceWindow
+  );
+  EventUtils.synthesizeMouseAtCenter(
+    dayPicker.querySelector(`[label="${fri}"]`),
+    {},
+    recurrenceWindow
+  );
+
+  // Set until date.
+  EventUtils.synthesizeMouseAtCenter(
+    recurrenceDocument.getElementById("recurrence-range-until"),
+    {},
+    recurrenceWindow
+  );
+
+  // Delete previous date.
+  let untilInput = recurrenceDocument.getElementById("repeat-until-date");
+  untilInput.focus();
+  EventUtils.synthesizeKey("a", { accelKey: true }, recurrenceWindow);
+  untilInput.focus();
+  EventUtils.synthesizeKey("VK_DELETE", {}, recurrenceWindow);
+
+  let endDateString = formatDate(ENDDATE);
+  EventUtils.sendString(endDateString, recurrenceWindow);
+
+  // Move focus to ensure the date is selected.
+  untilInput.focus();
+  EventUtils.synthesizeKey("VK_TAB", {}, recurrenceWindow);
+
+  let button = recurrenceDocument.querySelector("dialog").getButton("accept");
+  button.scrollIntoView();
+  // Close dialog.
+  EventUtils.synthesizeMouseAtCenter(button, {}, recurrenceWindow);
+}
diff --git a/comm/calendar/test/browser/recurrence/browser_weeklyWithException.js b/comm/calendar/test/browser/recurrence/browser_weeklyWithException.js
new file mode 100644
index 0000000000..fbe007ea45
--- /dev/null
+++ b/comm/calendar/test/browser/recurrence/browser_weeklyWithException.js
@@ -0,0 +1,264 @@
+/* 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 { handleDeleteOccurrencePrompt } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarUtils.jsm"
+);
+
+var { menulistSelect, saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+var { dayView, weekView, multiweekView, monthView } = CalendarTestUtils;
+
+const HOUR = 8;
+const STARTDATE = cal.createDateTime("20090106T000000Z");
+const TITLE = "Event";
+
+add_task(async function testWeeklyWithExceptionRecurrence() {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 5);
+
+  // Create weekly recurring event.
+  let eventBox = dayView.getHourBoxAt(window, HOUR);
+  let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, eventBox);
+  await setData(dialogWindow, iframeWindow, { title: TITLE, repeat: setRecurrence });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  let eventItem = await dayView.waitForEventBoxAt(window, 1);
+  let icon = eventItem.querySelector(".item-recurrence-icon");
+  Assert.equal(icon.src, "chrome://messenger/skin/icons/new/recurrence.svg");
+  Assert.ok(!icon.hidden);
+
+  // Move 5th January occurrence to 6th January.
+  ({ dialogWindow, iframeWindow } = await dayView.editEventOccurrenceAt(window, 1));
+  await setData(dialogWindow, iframeWindow, {
+    title: TITLE,
+    startdate: STARTDATE,
+    enddate: STARTDATE,
+  });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  await CalendarTestUtils.goToDate(window, 2009, 1, 6);
+  eventItem = await dayView.waitForEventBoxAt(window, 1);
+  icon = eventItem.querySelector(".item-recurrence-icon");
+  Assert.equal(icon.src, "chrome://messenger/skin/icons/new/recurrence-exception.svg");
+
+  // Change recurrence rule.
+  await CalendarTestUtils.goToDate(window, 2009, 1, 7);
+  ({ dialogWindow, iframeWindow } = await dayView.editEventOccurrencesAt(window, 1));
+  await setData(dialogWindow, iframeWindow, {
+    title: "Event",
+    repeat: changeRecurrence,
+  });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Check two weeks.
+  // day view
+  await CalendarTestUtils.setCalendarView(window, "day");
+
+  await CalendarTestUtils.goToDate(window, 2009, 1, 5);
+  await dayView.waitForNoEventBoxAt(window, 1);
+
+  await CalendarTestUtils.calendarViewForward(window, 1);
+
+  // Assert exactly two.
+  Assert.ok(!!(await dayView.waitForEventBoxAt(window, 1)));
+  Assert.ok(!!(await dayView.waitForEventBoxAt(window, 2)));
+
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await dayView.waitForEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await dayView.waitForNoEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await dayView.waitForEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await dayView.waitForNoEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await dayView.waitForNoEventBoxAt(window, 1);
+
+  // next week
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await dayView.waitForEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await dayView.waitForEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await dayView.waitForEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await dayView.waitForNoEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await dayView.waitForEventBoxAt(window, 1);
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await dayView.waitForNoEventBoxAt(window, 1);
+
+  // week view
+  await CalendarTestUtils.setCalendarView(window, "week");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 5);
+
+  // Assert exactly two on Tuesday.
+  Assert.ok(!!(await weekView.waitForEventBoxAt(window, 3, 1)));
+  Assert.ok(!!(await weekView.waitForEventBoxAt(window, 3, 2)));
+
+  // Wait for the last occurrence because this appears last.
+  eventItem = await weekView.waitForEventBoxAt(window, 6, 1);
+  icon = eventItem.querySelector(".item-recurrence-icon");
+  Assert.equal(icon.src, "chrome://messenger/skin/icons/new/recurrence.svg");
+  Assert.ok(!icon.hidden);
+
+  Assert.ok(!weekView.getEventBoxAt(window, 1, 1));
+  Assert.ok(!weekView.getEventBoxAt(window, 2, 1));
+  Assert.ok(!!weekView.getEventBoxAt(window, 4, 1));
+  Assert.ok(!weekView.getEventBoxAt(window, 5, 1));
+  Assert.ok(!weekView.getEventBoxAt(window, 7, 1));
+
+  await CalendarTestUtils.calendarViewForward(window, 1);
+  await weekView.waitForEventBoxAt(window, 6, 1);
+  Assert.ok(!weekView.getEventBoxAt(window, 1, 1));
+  Assert.ok(!!weekView.getEventBoxAt(window, 2, 1));
+  Assert.ok(!!weekView.getEventBoxAt(window, 3, 1));
+  Assert.ok(!!weekView.getEventBoxAt(window, 4, 1));
+  Assert.ok(!weekView.getEventBoxAt(window, 5, 1));
+  Assert.ok(!weekView.getEventBoxAt(window, 7, 1));
+
+  // multiweek view
+  await CalendarTestUtils.setCalendarView(window, "multiweek");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 5);
+  // Wait for the first items, then check the ones not to be present.
+  // Assert exactly two.
+  await multiweekView.waitForItemAt(window, 1, 3, 1, 1);
+  Assert.ok(multiweekView.getItemAt(window, 1, 3, 2, 1));
+  Assert.ok(!multiweekView.getItemAt(window, 1, 3, 3, 1));
+  // Then check no item on the 5th.
+  Assert.ok(!multiweekView.getItemAt(window, 1, 2, 1));
+  Assert.ok(multiweekView.getItemAt(window, 1, 4, 1));
+  Assert.ok(!multiweekView.getItemAt(window, 1, 5, 1));
+  Assert.ok(multiweekView.getItemAt(window, 1, 6, 1));
+  Assert.ok(!multiweekView.getItemAt(window, 1, 7, 1));
+
+  Assert.ok(!multiweekView.getItemAt(window, 2, 1, 1));
+  Assert.ok(multiweekView.getItemAt(window, 2, 2, 1));
+  Assert.ok(multiweekView.getItemAt(window, 2, 3, 1));
+  Assert.ok(multiweekView.getItemAt(window, 2, 4, 1));
+  Assert.ok(!multiweekView.getItemAt(window, 2, 5, 1));
+  Assert.ok(multiweekView.getItemAt(window, 2, 6, 1));
+  Assert.ok(!multiweekView.getItemAt(window, 2, 7, 1));
+
+  eventItem = multiweekView.getItemAt(window, 2, 4, 1);
+  icon = eventItem.querySelector(".item-recurrence-icon");
+  Assert.equal(icon.src, "chrome://messenger/skin/icons/new/recurrence.svg");
+  Assert.ok(!icon.hidden);
+
+  // month view
+  await CalendarTestUtils.setCalendarView(window, "month");
+  // Wait for the first items, then check the ones not to be present.
+  // Assert exactly two.
+  // start on the second week
+  await monthView.waitForItemAt(window, 2, 3, 1);
+  Assert.ok(monthView.getItemAt(window, 2, 3, 2));
+  Assert.ok(!monthView.getItemAt(window, 2, 3, 3));
+  // Then check no item on the 5th.
+  Assert.ok(!monthView.getItemAt(window, 2, 2, 1));
+  Assert.ok(monthView.getItemAt(window, 2, 4, 1));
+  Assert.ok(!monthView.getItemAt(window, 2, 5, 1));
+  Assert.ok(monthView.getItemAt(window, 2, 6, 1));
+  Assert.ok(!monthView.getItemAt(window, 2, 7, 1));
+
+  Assert.ok(!monthView.getItemAt(window, 3, 1, 1));
+  Assert.ok(monthView.getItemAt(window, 3, 2, 1));
+  Assert.ok(monthView.getItemAt(window, 3, 3, 1));
+  Assert.ok(monthView.getItemAt(window, 3, 4, 1));
+  Assert.ok(!monthView.getItemAt(window, 3, 5, 1));
+  Assert.ok(monthView.getItemAt(window, 3, 6, 1));
+  Assert.ok(!monthView.getItemAt(window, 3, 7, 1));
+
+  eventItem = monthView.getItemAt(window, 3, 6, 1);
+  icon = eventItem.querySelector(".item-recurrence-icon");
+  Assert.equal(icon.src, "chrome://messenger/skin/icons/new/recurrence.svg");
+  Assert.ok(!icon.hidden);
+
+  // Delete event.
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 12);
+  eventBox = await dayView.waitForEventBoxAt(window, 1);
+  EventUtils.synthesizeMouseAtCenter(eventBox, {}, window);
+  await handleDeleteOccurrencePrompt(window, eventBox, true);
+  await dayView.waitForNoEventBoxAt(window, 1);
+
+  Assert.ok(true, "Test ran to completion");
+});
+
+async function setRecurrence(recurrenceWindow) {
+  let recurrenceDocument = recurrenceWindow.document;
+
+  // weekly
+  await menulistSelect(recurrenceDocument.getElementById("period-list"), "1");
+
+  let mon = cal.l10n.getDateFmtString("day.2.Mmm");
+  let wed = cal.l10n.getDateFmtString("day.4.Mmm");
+  let fri = cal.l10n.getDateFmtString("day.6.Mmm");
+
+  let dayPicker = recurrenceDocument.getElementById("daypicker-weekday");
+
+  // Starting from Monday so it should be checked.
+  Assert.ok(dayPicker.querySelector(`[label="${mon}"]`).checked, "mon checked");
+
+  // Check Wednesday and Friday too.
+  EventUtils.synthesizeMouseAtCenter(
+    dayPicker.querySelector(`[label="${wed}"]`),
+    {},
+    recurrenceWindow
+  );
+  Assert.ok(dayPicker.querySelector(`[label="${wed}"]`).checked, "wed checked");
+  EventUtils.synthesizeMouseAtCenter(
+    dayPicker.querySelector(`[label="${fri}"]`),
+    {},
+    recurrenceWindow
+  );
+  Assert.ok(dayPicker.querySelector(`[label="${fri}"]`).checked, "fri checked");
+
+  let button = recurrenceDocument.querySelector("dialog").getButton("accept");
+  button.scrollIntoView();
+  // Close dialog.
+  EventUtils.synthesizeMouseAtCenter(button, {}, recurrenceWindow);
+}
+
+async function changeRecurrence(recurrenceWindow) {
+  let recurrenceDocument = recurrenceWindow.document;
+
+  // weekly
+  await menulistSelect(recurrenceDocument.getElementById("period-list"), "1");
+
+  let mon = cal.l10n.getDateFmtString("day.2.Mmm");
+  let tue = cal.l10n.getDateFmtString("day.3.Mmm");
+  let wed = cal.l10n.getDateFmtString("day.4.Mmm");
+  let fri = cal.l10n.getDateFmtString("day.6.Mmm");
+
+  let dayPicker = recurrenceDocument.getElementById("daypicker-weekday");
+
+  // Check old rule.
+  // Starting from Monday so it should be checked.
+  Assert.ok(dayPicker.querySelector(`[label="${mon}"]`).checked, "mon checked");
+  Assert.ok(dayPicker.querySelector(`[label="${wed}"]`).checked, "wed checked");
+  Assert.ok(dayPicker.querySelector(`[label="${fri}"]`).checked, "fri checked");
+
+  // Check Tuesday.
+  EventUtils.synthesizeMouseAtCenter(
+    dayPicker.querySelector(`[label="${tue}"]`),
+    {},
+    recurrenceWindow
+  );
+  Assert.ok(dayPicker.querySelector(`[label="${tue}"]`).checked, "tue checked");
+
+  let button = recurrenceDocument.querySelector("dialog").getButton("accept");
+  button.scrollIntoView();
+  // Close dialog.
+  EventUtils.synthesizeMouseAtCenter(button, {}, recurrenceWindow);
+}
diff --git a/comm/calendar/test/browser/recurrence/head.js b/comm/calendar/test/browser/recurrence/head.js
new file mode 100644
index 0000000000..efcee250b6
--- /dev/null
+++ b/comm/calendar/test/browser/recurrence/head.js
@@ -0,0 +1,26 @@
+/* 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/. */
+
+// The tests in this folder frequently take too long. Give them more time.
+requestLongerTimeout(2);
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+/* globals toggleOrientation */
+
+let isRotated =
+  document.getElementById("calendar_toggle_orientation_command").getAttribute("checked") == "true";
+let shouldBeRotated = Services.prefs.getBoolPref("calendar.test.rotateViews", false);
+
+if (isRotated != shouldBeRotated) {
+  toggleOrientation();
+}
+
+const calendarViewsInitialState = CalendarTestUtils.saveCalendarViewsState(window);
+
+registerCleanupFunction(async () => {
+  await CalendarTestUtils.restoreCalendarViewsState(window, calendarViewsInitialState);
+});
diff --git a/comm/calendar/test/browser/timezones/browser.ini b/comm/calendar/test/browser/timezones/browser.ini
new file mode 100644
index 0000000000..2fe2a0b4ea
--- /dev/null
+++ b/comm/calendar/test/browser/timezones/browser.ini
@@ -0,0 +1,17 @@
+[default]
+prefs =
+  calendar.item.promptDelete=false
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+  calendar.week.start=0
+  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
+support-files = data/**
+
+[browser_minimonth.js]
+[browser_timezones.js]
+skip-if = debug # Takes way too long, bug 1746973.
diff --git a/comm/calendar/test/browser/timezones/browser_minimonth.js b/comm/calendar/test/browser/timezones/browser_minimonth.js
new file mode 100644
index 0000000000..eba6bb2485
--- /dev/null
+++ b/comm/calendar/test/browser/timezones/browser_minimonth.js
@@ -0,0 +1,215 @@
+/* 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/. */
+
+/**
+ * Tests the minimonth widget in a range of time zones. It will fail if the
+ * widget loses time zone awareness.
+ */
+
+/* eslint-disable no-restricted-syntax */
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+add_setup(async function () {
+  await CalendarTestUtils.openCalendarTab(window);
+});
+
+registerCleanupFunction(async function () {
+  await CalendarTestUtils.closeCalendarTab(window);
+  Services.prefs.setStringPref("calendar.timezone.local", "UTC");
+});
+
+async function subtest() {
+  let zone = cal.dtz.defaultTimezone;
+  info(`Running test in ${zone.tzid}`);
+
+  // Set the minimonth to display August 2016.
+  let minimonth = document.getElementById("calMinimonth");
+  minimonth.showMonth(new Date(2016, 7, 15));
+
+  Assert.deepEqual(
+    [...minimonth.dayBoxes.keys()],
+    [
+      "2016-07-31",
+      "2016-08-01",
+      "2016-08-02",
+      "2016-08-03",
+      "2016-08-04",
+      "2016-08-05",
+      "2016-08-06",
+      "2016-08-07",
+      "2016-08-08",
+      "2016-08-09",
+      "2016-08-10",
+      "2016-08-11",
+      "2016-08-12",
+      "2016-08-13",
+      "2016-08-14",
+      "2016-08-15",
+      "2016-08-16",
+      "2016-08-17",
+      "2016-08-18",
+      "2016-08-19",
+      "2016-08-20",
+      "2016-08-21",
+      "2016-08-22",
+      "2016-08-23",
+      "2016-08-24",
+      "2016-08-25",
+      "2016-08-26",
+      "2016-08-27",
+      "2016-08-28",
+      "2016-08-29",
+      "2016-08-30",
+      "2016-08-31",
+      "2016-09-01",
+      "2016-09-02",
+      "2016-09-03",
+      "2016-09-04",
+      "2016-09-05",
+      "2016-09-06",
+      "2016-09-07",
+      "2016-09-08",
+      "2016-09-09",
+      "2016-09-10",
+    ],
+    "day boxes are stored with the correct keys"
+  );
+
+  function check(date, row, column) {
+    if (date instanceof Date) {
+      info(date);
+    } else {
+      info(`${date} ${date.timezone.tzid}`);
+    }
+    if (row && column) {
+      Assert.equal(minimonth.getBoxForDate(date), minimonth.mCalBox.rows[row].cells[column]);
+    } else {
+      Assert.equal(minimonth.getBoxForDate(date), null);
+    }
+  }
+
+  let dateWithZone = cal.createDateTime();
+
+  // Dates without timezones or the local timezone.
+
+  // All of these represent the 1st of August.
+  check(new Date(2016, 7, 1), 1, 2);
+  check(new Date(2016, 7, 1, 9, 0, 0), 1, 2);
+  check(new Date(2016, 7, 1, 22, 0, 0), 1, 2);
+
+  check(cal.createDateTime("20160801"), 1, 2);
+  check(cal.createDateTime("20160801T030000"), 1, 2);
+  check(cal.createDateTime("20160801T210000"), 1, 2);
+
+  dateWithZone.resetTo(2016, 7, 1, 3, 0, 0, zone);
+  check(dateWithZone, 1, 2);
+  dateWithZone.resetTo(2016, 7, 1, 21, 0, 0, zone);
+  check(dateWithZone, 1, 2);
+
+  // All of these represent the 31st of August.
+  check(new Date(2016, 7, 31), 5, 4);
+  check(new Date(2016, 7, 31, 9, 0, 0), 5, 4);
+  check(new Date(2016, 7, 31, 22, 0, 0), 5, 4);
+
+  check(cal.createDateTime("20160831"), 5, 4);
+  check(cal.createDateTime("20160831T030000"), 5, 4);
+  check(cal.createDateTime("20160831T210000"), 5, 4);
+
+  dateWithZone.resetTo(2016, 7, 31, 3, 0, 0, zone);
+  check(dateWithZone, 5, 4);
+  dateWithZone.resetTo(2016, 7, 31, 21, 0, 0, zone);
+  check(dateWithZone, 5, 4);
+
+  // August a year earlier shouldn't be displayed.
+  check(new Date(2015, 7, 15));
+  check(cal.createDateTime("20150815"));
+  dateWithZone.resetTo(2015, 7, 15, 0, 0, 0, zone);
+  check(dateWithZone);
+
+  // The Saturday of the previous week shouldn't be displayed.
+  check(new Date(2016, 6, 30));
+  check(cal.createDateTime("20160730"));
+  dateWithZone.resetTo(2016, 6, 30, 0, 0, 0, zone);
+  check(dateWithZone);
+
+  // The Sunday of the next week shouldn't be displayed.
+  check(new Date(2016, 8, 11));
+  check(cal.createDateTime("20160911"));
+  dateWithZone.resetTo(2016, 8, 11, 0, 0, 0, zone);
+  check(dateWithZone);
+
+  // August a year later shouldn't be displayed.
+  check(new Date(2017, 7, 15));
+  check(cal.createDateTime("20170815"));
+  dateWithZone.resetTo(2017, 7, 15, 0, 0, 0, zone);
+  check(dateWithZone);
+
+  // UTC dates.
+
+  check(cal.createDateTime("20160801T030000Z"), 1, zone.tzid == "America/Vancouver" ? 1 : 2);
+  check(cal.createDateTime("20160801T210000Z"), 1, zone.tzid == "Pacific/Auckland" ? 3 : 2);
+
+  check(cal.createDateTime("20160831T030000Z"), 5, zone.tzid == "America/Vancouver" ? 3 : 4);
+  check(cal.createDateTime("20160831T210000Z"), 5, zone.tzid == "Pacific/Auckland" ? 5 : 4);
+
+  // Dates in different zones.
+
+  let auckland = cal.timezoneService.getTimezone("Pacific/Auckland");
+  let vancouver = cal.timezoneService.getTimezone("America/Vancouver");
+
+  // Early in Auckland is the previous day everywhere else.
+  dateWithZone.resetTo(2016, 7, 15, 3, 0, 0, auckland);
+  check(dateWithZone, 3, zone.tzid == "Pacific/Auckland" ? 2 : 1);
+
+  // Late in Auckland is the same day everywhere.
+  dateWithZone.resetTo(2016, 7, 15, 21, 0, 0, auckland);
+  check(dateWithZone, 3, 2);
+
+  // Early in Vancouver is the same day everywhere.
+  dateWithZone.resetTo(2016, 7, 15, 3, 0, 0, vancouver);
+  check(dateWithZone, 3, 2);
+
+  // Late in Vancouver is the next day everywhere else.
+  dateWithZone.resetTo(2016, 7, 15, 21, 0, 0, vancouver);
+  check(dateWithZone, 3, zone.tzid == "America/Vancouver" ? 2 : 3);
+
+  // Reset the minimonth to a different month.
+  minimonth.showMonth(new Date(2016, 9, 15));
+}
+
+/**
+ * Run the test at UTC+12.
+ */
+add_task(async function auckland() {
+  Services.prefs.setStringPref("calendar.timezone.local", "Pacific/Auckland");
+  await subtest();
+});
+
+/**
+ * Run the test at UTC+2.
+ */
+add_task(async function berlin() {
+  Services.prefs.setStringPref("calendar.timezone.local", "Europe/Berlin");
+  await subtest();
+});
+
+/**
+ * Run the test at UTC.
+ */
+add_task(async function utc() {
+  Services.prefs.setStringPref("calendar.timezone.local", "UTC");
+  await subtest();
+});
+
+/**
+ * Run the test at UTC-7.
+ */
+add_task(async function vancouver() {
+  Services.prefs.setStringPref("calendar.timezone.local", "America/Vancouver");
+  await subtest();
+});
diff --git a/comm/calendar/test/browser/timezones/browser_timezones.js b/comm/calendar/test/browser/timezones/browser_timezones.js
new file mode 100644
index 0000000000..41ce97027a
--- /dev/null
+++ b/comm/calendar/test/browser/timezones/browser_timezones.js
@@ -0,0 +1,867 @@
+/* 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/. */
+
+requestLongerTimeout(3);
+
+var { findEventsInNode } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarUtils.jsm"
+);
+var { saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+var DATES = [
+  [2009, 1, 1],
+  [2009, 4, 2],
+  [2009, 4, 16],
+  [2009, 4, 30],
+  [2009, 7, 2],
+  [2009, 10, 15],
+  [2009, 10, 29],
+  [2009, 11, 5],
+];
+
+var TIMEZONES = [
+  "America/St_Johns",
+  "America/Caracas", // standard time UTC-4:30 from 2007 to 2016
+  "America/Phoenix",
+  "America/Los_Angeles",
+  "America/Buenos_Aires", // standard time UTC-3, DST UTC-4 from October 2008 to March 2009
+  "Europe/Paris",
+  "Asia/Katmandu",
+  "Australia/Adelaide",
+];
+
+const calendarViewsInitialState = CalendarTestUtils.saveCalendarViewsState(window);
+
+add_setup(async () => {
+  registerCleanupFunction(async () => {
+    await CalendarTestUtils.restoreCalendarViewsState(window, calendarViewsInitialState);
+    Services.prefs.setStringPref("calendar.timezone.local", "UTC");
+  });
+
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  // Create weekly recurring events in all TIMEZONES.
+  let times = [
+    [4, 30],
+    [5, 0],
+    [3, 0],
+    [3, 0],
+    [9, 0],
+    [14, 0],
+    [19, 45],
+    [1, 30],
+  ];
+  let time = cal.createDateTime();
+  for (let i = 0; i < TIMEZONES.length; i++) {
+    let eventBox = CalendarTestUtils.dayView.getHourBoxAt(window, i + 11);
+    let { dialogWindow, iframeWindow } = await CalendarTestUtils.editNewEvent(window, eventBox);
+    time.hour = times[i][0];
+    time.minute = times[i][1];
+
+    // Set event data.
+    await setData(dialogWindow, iframeWindow, {
+      title: TIMEZONES[i],
+      repeat: "weekly",
+      repeatuntil: cal.createDateTime("20091231T000000Z"),
+      starttime: time,
+      timezone: TIMEZONES[i],
+    });
+
+    await saveAndCloseItemDialog(dialogWindow);
+  }
+});
+
+add_task(async function testTimezones3_checkStJohns() {
+  Services.prefs.setStringPref("calendar.timezone.local", "America/St_Johns");
+  let times = [
+    [
+      [4, 30],
+      [6, 0],
+      [6, 30],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [10, 30],
+      [11, 30],
+    ],
+    [
+      [4, 30],
+      [7, 0],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [9, 30],
+      [11, 30],
+      [12, 30],
+    ],
+    [
+      [4, 30],
+      [7, 0],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [9, 30],
+      [11, 30],
+      [13, 30],
+    ],
+    [
+      [4, 30],
+      [7, 0],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [9, 30],
+      [11, 30],
+      [13, 30],
+    ],
+    [
+      [4, 30],
+      [7, 0],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [9, 30],
+      [11, 30],
+      [13, 30],
+    ],
+    [
+      [4, 30],
+      [7, 0],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [9, 30],
+      [11, 30],
+      [12, 30],
+    ],
+    [
+      [4, 30],
+      [7, 0],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [10, 30],
+      [11, 30],
+      [12, 30],
+    ],
+    [
+      [4, 30],
+      [6, 0],
+      [6, 30],
+      [7, 30],
+      [8, 30],
+      [9, 30],
+      [10, 30],
+      [11, 30],
+    ],
+  ];
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("calendarButton"), {}, window);
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  await verify(DATES, TIMEZONES, times);
+});
+
+add_task(async function testTimezones4_checkCaracas() {
+  Services.prefs.setStringPref("calendar.timezone.local", "America/Caracas");
+  let times = [
+    [
+      [3, 30],
+      [5, 0],
+      [5, 30],
+      [6, 30],
+      [6, 30],
+      [8, 30],
+      [9, 30],
+      [10, 30],
+    ],
+    [
+      [2, 30],
+      [5, 0],
+      [5, 30],
+      [5, 30],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [10, 30],
+    ],
+    [
+      [2, 30],
+      [5, 0],
+      [5, 30],
+      [5, 30],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [11, 30],
+    ],
+    [
+      [2, 30],
+      [5, 0],
+      [5, 30],
+      [5, 30],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [11, 30],
+    ],
+    [
+      [2, 30],
+      [5, 0],
+      [5, 30],
+      [5, 30],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [11, 30],
+    ],
+    [
+      [2, 30],
+      [5, 0],
+      [5, 30],
+      [5, 30],
+      [7, 30],
+      [7, 30],
+      [9, 30],
+      [10, 30],
+    ],
+    [
+      [2, 30],
+      [5, 0],
+      [5, 30],
+      [5, 30],
+      [7, 30],
+      [8, 30],
+      [9, 30],
+      [10, 30],
+    ],
+    [
+      [3, 30],
+      [5, 0],
+      [5, 30],
+      [6, 30],
+      [7, 30],
+      [8, 30],
+      [9, 30],
+      [10, 30],
+    ],
+  ];
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("calendarButton"), {}, window);
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  await verify(DATES, TIMEZONES, times);
+});
+
+add_task(async function testTimezones5_checkPhoenix() {
+  Services.prefs.setStringPref("calendar.timezone.local", "America/Phoenix");
+  let times = [
+    [
+      [1, 0],
+      [2, 30],
+      [3, 0],
+      [4, 0],
+      [4, 0],
+      [6, 0],
+      [7, 0],
+      [8, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [5, 0],
+      [7, 0],
+      [8, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [5, 0],
+      [7, 0],
+      [9, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [5, 0],
+      [7, 0],
+      [9, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [5, 0],
+      [7, 0],
+      [9, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [5, 0],
+      [7, 0],
+      [8, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [6, 0],
+      [7, 0],
+      [8, 0],
+    ],
+    [
+      [1, 0],
+      [2, 30],
+      [3, 0],
+      [4, 0],
+      [5, 0],
+      [6, 0],
+      [7, 0],
+      [8, 0],
+    ],
+  ];
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("calendarButton"), {}, window);
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  await verify(DATES, TIMEZONES, times);
+});
+
+add_task(async function testTimezones6_checkLosAngeles() {
+  Services.prefs.setStringPref("calendar.timezone.local", "America/Los_Angeles");
+  let times = [
+    [
+      [0, 0],
+      [1, 30],
+      [2, 0],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [6, 0],
+      [7, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [5, 0],
+      [7, 0],
+      [8, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [5, 0],
+      [7, 0],
+      [9, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [5, 0],
+      [7, 0],
+      [9, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [5, 0],
+      [7, 0],
+      [9, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [5, 0],
+      [7, 0],
+      [8, 0],
+    ],
+    [
+      [0, 0],
+      [2, 30],
+      [3, 0],
+      [3, 0],
+      [5, 0],
+      [6, 0],
+      [7, 0],
+      [8, 0],
+    ],
+    [
+      [0, 0],
+      [1, 30],
+      [2, 0],
+      [3, 0],
+      [4, 0],
+      [5, 0],
+      [6, 0],
+      [7, 0],
+    ],
+  ];
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("calendarButton"), {}, window);
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  await verify(DATES, TIMEZONES, times);
+});
+
+add_task(async function testTimezones7_checkBuenosAires() {
+  Services.prefs.setStringPref("calendar.timezone.local", "America/Argentina/Buenos_Aires");
+  let times = [
+    [
+      [6, 0],
+      [7, 30],
+      [8, 0],
+      [9, 0],
+      [9, 0],
+      [11, 0],
+      [12, 0],
+      [13, 0],
+    ],
+    [
+      [4, 0],
+      [6, 30],
+      [7, 0],
+      [7, 0],
+      [9, 0],
+      [9, 0],
+      [11, 0],
+      [12, 0],
+    ],
+    [
+      [4, 0],
+      [6, 30],
+      [7, 0],
+      [7, 0],
+      [9, 0],
+      [9, 0],
+      [11, 0],
+      [13, 0],
+    ],
+    [
+      [4, 0],
+      [6, 30],
+      [7, 0],
+      [7, 0],
+      [9, 0],
+      [9, 0],
+      [11, 0],
+      [13, 0],
+    ],
+    [
+      [4, 0],
+      [6, 30],
+      [7, 0],
+      [7, 0],
+      [9, 0],
+      [9, 0],
+      [11, 0],
+      [13, 0],
+    ],
+    [
+      [4, 0],
+      [6, 30],
+      [7, 0],
+      [7, 0],
+      [9, 0],
+      [9, 0],
+      [11, 0],
+      [12, 0],
+    ],
+    [
+      [4, 0],
+      [6, 30],
+      [7, 0],
+      [7, 0],
+      [9, 0],
+      [10, 0],
+      [11, 0],
+      [12, 0],
+    ],
+    [
+      [5, 0],
+      [6, 30],
+      [7, 0],
+      [8, 0],
+      [9, 0],
+      [10, 0],
+      [11, 0],
+      [12, 0],
+    ],
+  ];
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("calendarButton"), {}, window);
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  await verify(DATES, TIMEZONES, times);
+});
+
+add_task(async function testTimezones8_checkParis() {
+  Services.prefs.setStringPref("calendar.timezone.local", "Europe/Paris");
+  let times = [
+    [
+      [9, 0],
+      [10, 30],
+      [11, 0],
+      [12, 0],
+      [12, 0],
+      [14, 0],
+      [15, 0],
+      [16, 0],
+    ],
+    [
+      [9, 0],
+      [11, 30],
+      [12, 0],
+      [12, 0],
+      [14, 0],
+      [14, 0],
+      [16, 0],
+      [17, 0],
+    ],
+    [
+      [9, 0],
+      [11, 30],
+      [12, 0],
+      [12, 0],
+      [14, 0],
+      [14, 0],
+      [16, 0],
+      [18, 0],
+    ],
+    [
+      [9, 0],
+      [11, 30],
+      [12, 0],
+      [12, 0],
+      [14, 0],
+      [14, 0],
+      [16, 0],
+      [18, 0],
+    ],
+    [
+      [9, 0],
+      [11, 30],
+      [12, 0],
+      [12, 0],
+      [14, 0],
+      [14, 0],
+      [16, 0],
+      [18, 0],
+    ],
+    [
+      [9, 0],
+      [11, 30],
+      [12, 0],
+      [12, 0],
+      [14, 0],
+      [14, 0],
+      [16, 0],
+      [17, 0],
+    ],
+    [
+      [8, 0],
+      [10, 30],
+      [11, 0],
+      [11, 0],
+      [13, 0],
+      [14, 0],
+      [15, 0],
+      [16, 0],
+    ],
+    [
+      [9, 0],
+      [10, 30],
+      [11, 0],
+      [12, 0],
+      [13, 0],
+      [14, 0],
+      [15, 0],
+      [16, 0],
+    ],
+  ];
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("calendarButton"), {}, window);
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  await verify(DATES, TIMEZONES, times);
+});
+
+add_task(async function testTimezones9_checkKathmandu() {
+  Services.prefs.setStringPref("calendar.timezone.local", "Asia/Kathmandu");
+  let times = [
+    [
+      [13, 45],
+      [15, 15],
+      [15, 45],
+      [16, 45],
+      [16, 45],
+      [18, 45],
+      [19, 45],
+      [20, 45],
+    ],
+    [
+      [12, 45],
+      [15, 15],
+      [15, 45],
+      [15, 45],
+      [17, 45],
+      [17, 45],
+      [19, 45],
+      [20, 45],
+    ],
+    [
+      [12, 45],
+      [15, 15],
+      [15, 45],
+      [15, 45],
+      [17, 45],
+      [17, 45],
+      [19, 45],
+      [21, 45],
+    ],
+    [
+      [12, 45],
+      [15, 15],
+      [15, 45],
+      [15, 45],
+      [17, 45],
+      [17, 45],
+      [19, 45],
+      [21, 45],
+    ],
+    [
+      [12, 45],
+      [15, 15],
+      [15, 45],
+      [15, 45],
+      [17, 45],
+      [17, 45],
+      [19, 45],
+      [21, 45],
+    ],
+    [
+      [12, 45],
+      [15, 15],
+      [15, 45],
+      [15, 45],
+      [17, 45],
+      [17, 45],
+      [19, 45],
+      [20, 45],
+    ],
+    [
+      [12, 45],
+      [15, 15],
+      [15, 45],
+      [15, 45],
+      [17, 45],
+      [18, 45],
+      [19, 45],
+      [20, 45],
+    ],
+    [
+      [13, 45],
+      [15, 15],
+      [15, 45],
+      [16, 45],
+      [17, 45],
+      [18, 45],
+      [19, 45],
+      [20, 45],
+    ],
+  ];
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("calendarButton"), {}, window);
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  await verify(DATES, TIMEZONES, times);
+});
+
+add_task(async function testTimezones10_checkAdelaide() {
+  Services.prefs.setStringPref("calendar.timezone.local", "Australia/Adelaide");
+  let times = [
+    [
+      [18, 30],
+      [20, 0],
+      [20, 30],
+      [21, 30],
+      [21, 30],
+      [23, 30],
+      [0, 30, +1],
+      [1, 30, +1],
+    ],
+    [
+      [17, 30],
+      [20, 0],
+      [20, 30],
+      [20, 30],
+      [22, 30],
+      [22, 30],
+      [0, 30, +1],
+      [1, 30, +1],
+    ],
+    [
+      [16, 30],
+      [19, 0],
+      [19, 30],
+      [19, 30],
+      [21, 30],
+      [21, 30],
+      [23, 30],
+      [1, 30, +1],
+    ],
+    [
+      [16, 30],
+      [19, 0],
+      [19, 30],
+      [19, 30],
+      [21, 30],
+      [21, 30],
+      [23, 30],
+      [1, 30, +1],
+    ],
+    [
+      [16, 30],
+      [19, 0],
+      [19, 30],
+      [19, 30],
+      [21, 30],
+      [21, 30],
+      [23, 30],
+      [1, 30, +1],
+    ],
+    [
+      [17, 30],
+      [20, 0],
+      [20, 30],
+      [20, 30],
+      [22, 30],
+      [22, 30],
+      [0, 30, +1],
+      [1, 30, +1],
+    ],
+    [
+      [17, 30],
+      [20, 0],
+      [20, 30],
+      [20, 30],
+      [22, 30],
+      [23, 30],
+      [0, 30, +1],
+      [1, 30, +1],
+    ],
+    [
+      [18, 30],
+      [20, 0],
+      [20, 30],
+      [21, 30],
+      [22, 30],
+      [23, 30],
+      [0, 30, +1],
+      [1, 30, +1],
+    ],
+  ];
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("calendarButton"), {}, window);
+  await CalendarTestUtils.setCalendarView(window, "day");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  await verify(DATES, TIMEZONES, times);
+});
+
+async function verify(dates, timezones, times) {
+  function* datetimes() {
+    for (let idx = 0; idx < dates.length; idx++) {
+      yield [dates[idx][0], dates[idx][1], dates[idx][2], times[idx]];
+    }
+  }
+  let allowedDifference = 3;
+
+  for (let [selectedYear, selectedMonth, selectedDay, selectedTime] of datetimes()) {
+    info(`Verifying on day ${selectedDay}, month ${selectedMonth}, year ${selectedYear}`);
+    await CalendarTestUtils.goToDate(window, selectedYear, selectedMonth, selectedDay);
+
+    // Find event with timezone tz.
+    for (let tzIdx = 0; tzIdx < timezones.length; tzIdx++) {
+      let [hour, minutes, day] = selectedTime[tzIdx];
+      info(
+        `Verifying at ${hour} hours, ${minutes} minutes (offset: ${day || "none"}) ` +
+          `in timezone "${timezones[tzIdx]}"`
+      );
+
+      // following day
+      if (day == 1) {
+        await CalendarTestUtils.calendarViewForward(window, 1);
+      } else if (day == -1) {
+        await CalendarTestUtils.calendarViewBackward(window, 1);
+      }
+
+      let hourRect = CalendarTestUtils.dayView.getHourBoxAt(window, hour).getBoundingClientRect();
+      let timeY = hourRect.y + hourRect.height * (minutes / 60);
+
+      // Wait for at least one event box to exist.
+      await CalendarTestUtils.dayView.waitForEventBoxAt(window, 1);
+
+      let eventPositions = Array.from(CalendarTestUtils.dayView.getEventBoxes(window))
+        .filter(node => node.mOccurrence.title == timezones[tzIdx])
+        .map(node => node.getBoundingClientRect().y);
+
+      dump(`Looking for event at ${timeY}: found ${eventPositions.join(", ")}\n`);
+
+      if (day == 1) {
+        await CalendarTestUtils.calendarViewBackward(window, 1);
+      } else if (day == -1) {
+        await CalendarTestUtils.calendarViewForward(window, 1);
+      }
+
+      Assert.ok(
+        eventPositions.some(pos => Math.abs(timeY - pos) < allowedDifference),
+        `There should be an event box that starts at ${hour} hours, ${minutes} minutes`
+      );
+    }
+  }
+}
diff --git a/comm/calendar/test/browser/views/browser.ini b/comm/calendar/test/browser/views/browser.ini
new file mode 100644
index 0000000000..0aae8af9d0
--- /dev/null
+++ b/comm/calendar/test/browser/views/browser.ini
@@ -0,0 +1,32 @@
+[default]
+head = head.js
+prefs =
+  calendar.item.promptDelete=false
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+  # Default start of the week Thursday to make sure calendar isn't relying on
+  # built-in assumptions of week start.
+  calendar.week.start=4
+  # Default Sunday to "not a weekend" and Wednesday to "weekend" to make sure
+  # calendar isn't relying on built-in assumptions of work days.
+  calendar.week.d0sundaysoff=false
+  calendar.week.d3wednesdaysoff=true
+  # Default work hours to be from 3:00 to 12:00 to make sure calendar isn't
+  # relying on built-in assumptions of work hours.
+  calendar.view.daystarthour=3
+  calendar.view.dayendhour=12
+  calendar.view.visiblehours=3
+  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_dayView.js]
+[browser_monthView.js]
+[browser_multiweekView.js]
+[browser_propertyChanges.js]
+[browser_taskView.js]
+[browser_viewSwitch.js]
+[browser_weekView.js]
diff --git a/comm/calendar/test/browser/views/browser_dayView.js b/comm/calendar/test/browser/views/browser_dayView.js
new file mode 100644
index 0000000000..ba68a85eea
--- /dev/null
+++ b/comm/calendar/test/browser/views/browser_dayView.js
@@ -0,0 +1,185 @@
+/* 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 { formatDate, formatTime, saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+const TITLE1 = "Day View Event";
+const TITLE2 = "Day View Event Changed";
+const DESC = "Day View Event Description";
+
+add_setup(async function () {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+});
+
+add_task(async function testDayView() {
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  let dayView = document.getElementById("day-view");
+  // Verify date in view.
+  await TestUtils.waitForCondition(
+    () => dayView.dayColumns[0]?.date.icalString == "20090101",
+    "Inspecting the date"
+  );
+
+  // Create event at 8 AM.
+  let eventBox = CalendarTestUtils.dayView.getHourBoxAt(window, 8);
+  let { dialogWindow, iframeWindow, iframeDocument } = await CalendarTestUtils.editNewEvent(
+    window,
+    eventBox
+  );
+
+  // Check that the start time is correct.
+  let someDate = cal.createDateTime();
+  someDate.resetTo(2009, 0, 1, 8, 0, 0, cal.dtz.UTC);
+
+  let startPicker = iframeDocument.getElementById("event-starttime");
+  Assert.equal(startPicker._datepicker._inputField.value, formatDate(someDate));
+  Assert.equal(startPicker._timepicker._inputField.value, formatTime(someDate));
+
+  // Fill in title, description and calendar.
+  await setData(dialogWindow, iframeWindow, {
+    title: TITLE1,
+    description: DESC,
+    calendar: "Test",
+  });
+
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // If it was created successfully, it can be opened.
+  ({ dialogWindow, iframeWindow } = await CalendarTestUtils.dayView.editEventAt(window, 1));
+  await setData(dialogWindow, iframeWindow, { title: TITLE2 });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Check if name was saved.
+  await TestUtils.waitForCondition(() => {
+    eventBox = CalendarTestUtils.dayView.getEventBoxAt(window, 1);
+    if (!eventBox) {
+      return false;
+    }
+
+    let eventName = eventBox.querySelector(".event-name-label");
+    return eventName.textContent == TITLE2;
+  }, "event was modified in the view");
+
+  // Delete event
+  EventUtils.synthesizeMouseAtCenter(eventBox, {}, window);
+  eventBox.focus();
+  EventUtils.synthesizeKey("VK_DELETE", {}, window);
+  await CalendarTestUtils.dayView.waitForNoEventBoxAt(window, 1);
+
+  Assert.ok(true, "Test ran to completion");
+});
+
+add_task(async function testDayViewDateLabel() {
+  await CalendarTestUtils.goToDate(window, 2022, 4, 13);
+
+  let heading = CalendarTestUtils.dayView.getColumnHeading(window);
+  let labelSpan = heading.querySelector("span:not([hidden])");
+
+  Assert.equal(
+    labelSpan.textContent,
+    "Wednesday Apr 13",
+    "the date label should contain the displayed date in a human-readable string"
+  );
+});
+
+add_task(async function testDayViewCurrentDayHighlight() {
+  // Sanity check that this date (which should be in the past) is not today's
+  // date.
+  let today = new Date();
+  Assert.ok(today.getUTCFullYear() != 2022 || today.getUTCMonth() != 3 || today.getUTCDate() != 13);
+
+  // When displaying days which are not the current day, there should be no
+  // highlight.
+  await CalendarTestUtils.goToDate(window, 2022, 4, 13);
+
+  let container = CalendarTestUtils.dayView.getColumnContainer(window);
+  Assert.ok(
+    !container.classList.contains("day-column-today"),
+    "the displayed date should not be highlighted if it is not the current day"
+  );
+
+  // When displaying the current day, it should be highlighted.
+  await CalendarTestUtils.goToToday(window);
+
+  container = CalendarTestUtils.dayView.getColumnContainer(window);
+  Assert.ok(
+    container.classList.contains("day-column-today"),
+    "the displayed date should be highlighted if it is the current day"
+  );
+});
+
+add_task(async function testDayViewWorkDayHighlight() {
+  // The test configuration sets Sunday to be a work day, so it should not have
+  // the weekend background.
+  await CalendarTestUtils.goToDate(window, 2022, 4, 10);
+
+  let container = CalendarTestUtils.dayView.getColumnContainer(window);
+  Assert.ok(
+    !container.classList.contains("day-column-weekend"),
+    "the displayed date should not be highlighted if it is a work day"
+  );
+
+  await CalendarTestUtils.goToDate(window, 2022, 4, 13);
+
+  container = CalendarTestUtils.dayView.getColumnContainer(window);
+  Assert.ok(
+    container.classList.contains("day-column-weekend"),
+    "the displayed date should be highlighted if it is not a work day"
+  );
+});
+
+add_task(async function testDayViewNavbar() {
+  await CalendarTestUtils.goToDate(window, 2022, 4, 13);
+
+  let intervalDescription = CalendarTestUtils.getNavBarIntervalDescription(window);
+  Assert.equal(
+    intervalDescription.textContent,
+    "Wednesday, April 13, 2022",
+    "interval description should contain a description of the displayed date"
+  );
+
+  // Note that the value 14 here tests calculation of the calendar week based on
+  // the starting day of the week; if the calculation built in an assumption of
+  // Sunday or Monday as the starting day of the week, we would get 15 here.
+  let calendarWeek = CalendarTestUtils.getNavBarCalendarWeekBox(window);
+  Assert.equal(
+    calendarWeek.textContent,
+    "CW: 14",
+    "calendar week label should contain an indicator of which week contains displayed date"
+  );
+});
+
+add_task(async function testDayViewTodayButton() {
+  // Though this code is cribbed from the CalendarTestUtils, it should be
+  // duplicated in case the utility implementation changes.
+  let todayButton = CalendarTestUtils.getNavBarTodayButton(window);
+
+  EventUtils.synthesizeMouseAtCenter(todayButton, {}, window);
+  await CalendarTestUtils.ensureViewLoaded(window);
+
+  let displayedDate = CalendarTestUtils.dayView.getEventColumn(window).date;
+
+  let today = new Date();
+  Assert.equal(
+    displayedDate.year,
+    today.getUTCFullYear(),
+    "year of displayed date should be this year"
+  );
+  Assert.equal(
+    displayedDate.month,
+    today.getUTCMonth(),
+    "month of displayed date should be this month"
+  );
+  Assert.equal(displayedDate.day, today.getUTCDate(), "day of displayed date should be today");
+});
diff --git a/comm/calendar/test/browser/views/browser_monthView.js b/comm/calendar/test/browser/views/browser_monthView.js
new file mode 100644
index 0000000000..f3a385a3f5
--- /dev/null
+++ b/comm/calendar/test/browser/views/browser_monthView.js
@@ -0,0 +1,86 @@
+/* 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 { formatDate, formatTime, saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+const TITLE1 = "Month View Event";
+const TITLE2 = "Month View Event Changed";
+const DESC = "Month View Event Description";
+
+add_task(async function testMonthView() {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "month");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  // Verify date.
+  await TestUtils.waitForCondition(() => {
+    let dateLabel = document.querySelector(
+      '#month-view td[selected="true"] > calendar-month-day-box'
+    );
+    return dateLabel && dateLabel.mDate.icalString == "20090101";
+  }, "Inspecting the date");
+
+  // Create event.
+  // Thursday of 2009-01-05 should be the selected box in the first row with default settings.
+  let hour = new Date().getUTCHours(); // Remember time at click.
+  let eventBox = CalendarTestUtils.monthView.getDayBox(window, 1, 5);
+  let { dialogWindow, iframeWindow, iframeDocument } = await CalendarTestUtils.editNewEvent(
+    window,
+    eventBox
+  );
+
+  // Check that the start time is correct.
+  // Next full hour except last hour hour of the day.
+  let nextHour = hour == 23 ? hour : (hour + 1) % 24;
+  let someDate = cal.dtz.now();
+  someDate.resetTo(2009, 0, 5, nextHour, 0, 0, cal.dtz.UTC);
+
+  let startPicker = iframeDocument.getElementById("event-starttime");
+  Assert.equal(startPicker._datepicker._inputField.value, formatDate(someDate));
+  Assert.equal(startPicker._timepicker._inputField.value, formatTime(someDate));
+
+  // Fill in title, description and calendar.
+  await setData(dialogWindow, iframeWindow, {
+    title: TITLE1,
+    description: DESC,
+    calendar: "Test",
+  });
+
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // If it was created successfully, it can be opened.
+  ({ dialogWindow, iframeWindow } = await CalendarTestUtils.monthView.editItemAt(window, 1, 5, 1));
+  // Change title and save changes.
+  await setData(dialogWindow, iframeWindow, { title: TITLE2 });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Check if name was saved.
+  let eventName;
+  await TestUtils.waitForCondition(() => {
+    eventBox = CalendarTestUtils.monthView.getItemAt(window, 1, 5, 1);
+    if (!eventBox) {
+      return false;
+    }
+    eventName = eventBox.querySelector(".event-name-label").textContent;
+    return eventName == TITLE2;
+  }, "event name did not update in time");
+
+  Assert.equal(eventName, TITLE2);
+
+  // Delete event.
+  EventUtils.synthesizeMouseAtCenter(eventBox, {}, window);
+  eventBox.focus();
+  EventUtils.synthesizeKey("VK_DELETE", {}, window);
+  await CalendarTestUtils.monthView.waitForNoItemAt(window, 1, 5, 1);
+
+  Assert.ok(true, "Test ran to completion");
+});
diff --git a/comm/calendar/test/browser/views/browser_multiweekView.js b/comm/calendar/test/browser/views/browser_multiweekView.js
new file mode 100644
index 0000000000..feb8fcd3ec
--- /dev/null
+++ b/comm/calendar/test/browser/views/browser_multiweekView.js
@@ -0,0 +1,88 @@
+/* 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 { formatDate, formatTime, saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+const TITLE1 = "Multiweek View Event";
+const TITLE2 = "Multiweek View Event Changed";
+const DESC = "Multiweek View Event Description";
+
+add_task(async function () {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "multiweek");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  // Verify date.
+  await TestUtils.waitForCondition(() => {
+    let dateLabel = document.querySelector(
+      '#multiweek-view td[selected="true"] > calendar-month-day-box'
+    );
+    return dateLabel && dateLabel.mDate.icalString == "20090101";
+  }, "Inspecting the date");
+
+  // Create event.
+  // Thursday of 2009-01-05 should be the selected box in the first row with default settings.
+  let hour = new Date().getUTCHours(); // Remember time at click.
+  let eventBox = CalendarTestUtils.multiweekView.getDayBox(window, 1, 5);
+  let { dialogWindow, iframeWindow, iframeDocument } = await CalendarTestUtils.editNewEvent(
+    window,
+    eventBox
+  );
+
+  // Check that the start time is correct.
+  // Next full hour except last hour hour of the day.
+  let nextHour = hour == 23 ? hour : (hour + 1) % 24;
+  let someDate = cal.dtz.now();
+  someDate.resetTo(2009, 0, 5, nextHour, 0, 0, cal.dtz.UTC);
+
+  let startPicker = iframeDocument.getElementById("event-starttime");
+  Assert.equal(startPicker._datepicker._inputField.value, formatDate(someDate));
+  Assert.equal(startPicker._timepicker._inputField.value, formatTime(someDate));
+
+  // Fill in title, description and calendar.
+  await setData(dialogWindow, iframeWindow, {
+    title: TITLE1,
+    description: DESC,
+    calendar: "Test",
+  });
+
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // If it was created successfully, it can be opened.
+  ({ dialogWindow, iframeWindow } = await CalendarTestUtils.multiweekView.editItemAt(
+    window,
+    1,
+    5,
+    1
+  ));
+  // Change title and save changes.
+  await setData(dialogWindow, iframeWindow, { title: TITLE2 });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Check if name was saved.
+  await TestUtils.waitForCondition(() => {
+    eventBox = CalendarTestUtils.multiweekView.getItemAt(window, 1, 5, 1);
+    if (eventBox === null) {
+      return false;
+    }
+    let eventName = eventBox.querySelector(".event-name-label");
+    return eventName && eventName.textContent == TITLE2;
+  }, "Wait for the new title");
+
+  // Delete event.
+  EventUtils.synthesizeMouseAtCenter(eventBox, {}, window);
+  eventBox.focus();
+  EventUtils.synthesizeKey("VK_DELETE", {}, window);
+  await CalendarTestUtils.multiweekView.waitForNoItemAt(window, 1, 5, 1);
+
+  Assert.ok(true, "Test ran to completion");
+});
diff --git a/comm/calendar/test/browser/views/browser_propertyChanges.js b/comm/calendar/test/browser/views/browser_propertyChanges.js
new file mode 100644
index 0000000000..79848a0e73
--- /dev/null
+++ b/comm/calendar/test/browser/views/browser_propertyChanges.js
@@ -0,0 +1,248 @@
+/* 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/. */
+
+/** Tests that changes in a calendar's properties are reflected in the current view. */
+
+const { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+const { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+
+let composite = cal.view.getCompositeCalendar(window);
+
+// This is the calendar we're going to change the properties of.
+let thisCalendar = CalendarTestUtils.createCalendar("This Calendar", "memory");
+thisCalendar.setProperty("color", "#ffee22");
+
+// This calendar isn't going to change, and we'll check it doesn't.
+let notThisCalendar = CalendarTestUtils.createCalendar("Not This Calendar", "memory");
+notThisCalendar.setProperty("color", "#dd3333");
+
+add_setup(async function () {
+  let { dedent } = CalendarTestUtils;
+  await thisCalendar.addItem(
+    new CalEvent(dedent`
+    BEGIN:VEVENT
+    SUMMARY:This Event 1
+    DTSTART;VALUE=DATE:20160205
+    DTEND;VALUE=DATE:20160206
+    END:VEVENT
+  `)
+  );
+  await thisCalendar.addItem(
+    new CalEvent(dedent`
+    BEGIN:VEVENT
+    SUMMARY:This Event 2
+    DTSTART:20160205T130000Z
+    DTEND:20160205T150000Z
+    END:VEVENT
+  `)
+  );
+  await thisCalendar.addItem(
+    new CalEvent(dedent`
+    BEGIN:VEVENT
+    SUMMARY:This Event 3
+    DTSTART;VALUE=DATE:20160208
+    DTEND;VALUE=DATE:20160209
+    RRULE:FREQ=DAILY;INTERVAL=2;COUNT=3
+    END:VEVENT
+  `)
+  );
+
+  await notThisCalendar.addItem(
+    new CalEvent(dedent`
+    BEGIN:VEVENT
+    SUMMARY:Not This Event 1
+    DTSTART;VALUE=DATE:20160205
+    DTEND;VALUE=DATE:20160207
+    END:VEVENT
+  `)
+  );
+  await notThisCalendar.addItem(
+    new CalEvent(dedent`
+    BEGIN:VEVENT
+    SUMMARY:Not This Event 2
+    DTSTART:20160205T140000Z
+    DTEND:20160205T170000Z
+    END:VEVENT
+  `)
+  );
+});
+
+/**
+ * Assert whether the given event box is draggable (editable).
+ *
+ * @param {MozCalendarEventBox} eventBox - The event box to test.
+ * @param {boolean} draggable - Whether we expect it to be draggable.
+ * @param {string} message - A message for assertions.
+ */
+async function assertCanDrag(eventBox, draggable, message) {
+  // Hover to see if the drag gripbars appear.
+  let enterPromise = BrowserTestUtils.waitForEvent(eventBox, "mouseenter");
+  EventUtils.synthesizeMouseAtCenter(eventBox, { type: "mouseover" }, window);
+  await enterPromise;
+  Assert.equal(
+    BrowserTestUtils.is_visible(eventBox.startGripbar),
+    draggable,
+    `Start gripbar should be ${draggable ? "visible" : "hidden"} on hover: ${message}`
+  );
+  Assert.equal(
+    BrowserTestUtils.is_visible(eventBox.endGripbar),
+    draggable,
+    `End gripbar should be ${draggable ? "visible" : "hidden"} on hover: ${message}`
+  );
+}
+
+/**
+ * Assert whether the given event element is editable.
+ *
+ * @param {Element} eventElement - The event element to test.
+ * @param {boolean} editable - Whether we expect it to be editable.
+ * @param {string} message - A message for assertions.
+ */
+async function assertEditable(eventElement, editable, message) {
+  // FIXME: Have more ways to test if an event is editable (e.g. test the
+  // context menu)
+  if (eventElement.matches("calendar-event-box")) {
+    await CalendarTestUtils.assertEventBoxDraggable(eventElement, editable, editable, message);
+  }
+}
+
+async function subTest(viewName, boxSelector, thisBoxCount, notThisBoxCount) {
+  async function makeChangeWithReload(changeFunction) {
+    await changeFunction();
+    await CalendarTestUtils.ensureViewLoaded(window);
+  }
+
+  async function checkBoxItems(expectedCount, checkFunction) {
+    await TestUtils.waitForCondition(
+      () => view.querySelectorAll(boxSelector).length == expectedCount,
+      "waiting for the correct number of boxes to be displayed"
+    );
+    let boxItems = view.querySelectorAll(boxSelector);
+
+    if (!checkFunction) {
+      return;
+    }
+
+    for (let boxItem of boxItems) {
+      // TODO: why is it named `item` in some places and `occurrence` elsewhere?
+      let isThisCalendar =
+        (boxItem.item && boxItem.item.calendar == thisCalendar) ||
+        boxItem.occurrence.calendar == thisCalendar;
+      await checkFunction(boxItem, isThisCalendar);
+    }
+  }
+
+  let view = document.getElementById(`${viewName}-view`);
+
+  await CalendarTestUtils.setCalendarView(window, viewName);
+  await CalendarTestUtils.goToDate(window, 2016, 2, 5);
+
+  info("Check initial state.");
+
+  await checkBoxItems(thisBoxCount + notThisBoxCount, async (boxItem, isThisCalendar) => {
+    let style = getComputedStyle(boxItem);
+
+    if (isThisCalendar) {
+      Assert.equal(style.backgroundColor, "rgb(255, 238, 34)", "item background correct");
+      Assert.equal(style.color, "rgb(34, 34, 34)", "item foreground correct");
+    } else {
+      Assert.equal(
+        style.backgroundColor,
+        "rgb(221, 51, 51)",
+        "item background correct (not target calendar)"
+      );
+      Assert.equal(
+        style.color,
+        "rgb(255, 255, 255)",
+        "item foreground correct (not target calendar)"
+      );
+    }
+    await assertEditable(boxItem, true, "Initial event");
+  });
+
+  info("Change color.");
+
+  thisCalendar.setProperty("color", "#16a765");
+  await checkBoxItems(thisBoxCount + notThisBoxCount, async (boxItem, isThisCalendar) => {
+    let style = getComputedStyle(boxItem);
+
+    if (isThisCalendar) {
+      Assert.equal(style.backgroundColor, "rgb(22, 167, 101)", "item background correct");
+      Assert.equal(style.color, "rgb(255, 255, 255)", "item foreground correct");
+    } else {
+      Assert.equal(
+        style.backgroundColor,
+        "rgb(221, 51, 51)",
+        "item background correct (not target calendar)"
+      );
+      Assert.equal(
+        style.color,
+        "rgb(255, 255, 255)",
+        "item foreground correct (not target calendar)"
+      );
+    }
+  });
+
+  info("Reset color.");
+  thisCalendar.setProperty("color", "#ffee22");
+
+  info("Disable.");
+
+  thisCalendar.setProperty("disabled", true);
+  await checkBoxItems(notThisBoxCount);
+
+  info("Enable.");
+
+  await makeChangeWithReload(() => thisCalendar.setProperty("disabled", false));
+  await checkBoxItems(thisBoxCount + notThisBoxCount);
+
+  info("Hide.");
+
+  composite.removeCalendar(thisCalendar);
+  await checkBoxItems(notThisBoxCount);
+
+  info("Show.");
+
+  await makeChangeWithReload(() => composite.addCalendar(thisCalendar));
+  await checkBoxItems(thisBoxCount + notThisBoxCount);
+
+  info("Set read-only.");
+
+  await makeChangeWithReload(() => thisCalendar.setProperty("readOnly", true));
+  await checkBoxItems(thisBoxCount + notThisBoxCount, async (boxItem, isThisCalendar) => {
+    if (isThisCalendar) {
+      await assertEditable(boxItem, false, "In readonly calendar");
+    } else {
+      await assertEditable(boxItem, true, "In non-readonly calendar");
+    }
+  });
+
+  info("Clear read-only.");
+
+  await makeChangeWithReload(() => thisCalendar.setProperty("readOnly", false));
+  await checkBoxItems(thisBoxCount + notThisBoxCount, async boxItem => {
+    await assertEditable(boxItem, true, "In non-readonly calendar after clearing");
+  });
+}
+
+add_task(async function testMonthView() {
+  await subTest("month", "calendar-month-day-box-item", 5, 3);
+});
+
+add_task(async function testMultiWeekView() {
+  await subTest("multiweek", "calendar-month-day-box-item", 5, 3);
+});
+
+add_task(async function testWeekView() {
+  await subTest("week", "calendar-editable-item, .multiday-events-list calendar-event-box", 4, 3);
+});
+
+add_task(async function testDayView() {
+  await subTest("day", "calendar-editable-item, .multiday-events-list calendar-event-box", 2, 2);
+});
+
+registerCleanupFunction(async () => {
+  CalendarTestUtils.removeCalendar(thisCalendar);
+  CalendarTestUtils.removeCalendar(notThisCalendar);
+});
diff --git a/comm/calendar/test/browser/views/browser_taskView.js b/comm/calendar/test/browser/views/browser_taskView.js
new file mode 100644
index 0000000000..c049c9668f
--- /dev/null
+++ b/comm/calendar/test/browser/views/browser_taskView.js
@@ -0,0 +1,148 @@
+/* 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 { MID_SLEEP, execEventDialogCallback } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarUtils.jsm"
+);
+var { saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+const TITLE = "Task";
+const DESCRIPTION = "1. Do A\n2. Do B";
+const PERCENTCOMPLETE = "50";
+
+add_task(async function () {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  // Open task view.
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("tasksButton"), {}, window);
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(resolve => setTimeout(resolve, MID_SLEEP));
+
+  // Make sure that testing calendar is selected.
+  let calList = document.querySelector(`#calendar-list > [calendar-id="${calendar.id}"]`);
+  Assert.ok(calList);
+  EventUtils.synthesizeMouseAtCenter(calList, {}, window);
+
+  let taskTreeNode = document.getElementById("calendar-task-tree");
+  Assert.equal(taskTreeNode.mTaskArray.length, 0);
+
+  // Add task.
+  let taskInput = document.getElementById("view-task-edit-field");
+  taskInput.focus();
+  EventUtils.sendString(TITLE, window);
+  EventUtils.synthesizeKey("VK_RETURN", {}, window);
+
+  // Verify added.
+  await TestUtils.waitForCondition(
+    () => taskTreeNode.mTaskArray.length == 1,
+    "Added Task did not appear"
+  );
+
+  // Last added task is automatically selected so verify detail window data.
+  Assert.equal(document.getElementById("calendar-task-details-title").textContent, TITLE);
+
+  // Open added task
+  // Double-click on completion checkbox is ignored as opening action, so don't
+  // click at immediate left where the checkbox is located.
+  let eventWindowPromise = CalendarTestUtils.waitForEventDialog("edit");
+  let treeChildren = document.querySelector("#calendar-task-tree .calendar-task-treechildren");
+  Assert.ok(treeChildren);
+  EventUtils.synthesizeMouse(treeChildren, 50, 0, { clickCount: 2 }, window);
+
+  await eventWindowPromise;
+  await execEventDialogCallback(async (taskWindow, iframeWindow) => {
+    // Verify calendar.
+    Assert.equal(iframeWindow.document.getElementById("item-calendar").value, "Test");
+
+    await setData(taskWindow, iframeWindow, {
+      status: "needs-action",
+      percent: PERCENTCOMPLETE,
+      description: DESCRIPTION,
+    });
+
+    await saveAndCloseItemDialog(taskWindow);
+  });
+
+  Assert.less(taskTreeNode.mTaskArray.length, 2, "Should not have added task");
+  Assert.greater(taskTreeNode.mTaskArray.length, 0, "Should not have removed task");
+
+  // Verify description and status in details pane.
+  await TestUtils.waitForCondition(() => {
+    let desc = document.getElementById("calendar-task-details-description");
+    return desc && desc.contentDocument.body.innerText == DESCRIPTION;
+  }, "Calendar task description");
+  Assert.equal(document.getElementById("calendar-task-details-status").textContent, "Needs Action");
+
+  // This is a hack.
+  taskTreeNode.getTaskAtRow(0).calendar.setProperty("capabilities.priority.supported", true);
+
+  // Set high priority and verify it in detail pane.
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("task-actions-priority"), {}, window);
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(resolve => setTimeout(resolve, MID_SLEEP));
+
+  let priorityMenu = document.querySelector(
+    "#task-actions-priority-menupopup > .priority-1-menuitem"
+  );
+  Assert.ok(priorityMenu);
+  EventUtils.synthesizeMouseAtCenter(priorityMenu, {}, window);
+  await TestUtils.waitForCondition(
+    () => !document.getElementById("calendar-task-details-priority-high").hidden,
+    "#calendar-task-details-priority-high did not show"
+  );
+
+  // Verify that tooltip shows status, priority and percent complete.
+  let toolTipNode = document.getElementById("taskTreeTooltip");
+  toolTipNode.ownerGlobal.showToolTip(toolTipNode, taskTreeNode.getTaskAtRow(0));
+
+  function getTooltipDescription(index) {
+    return toolTipNode.querySelector(
+      `.tooltipHeaderTable > tr:nth-of-type(${index}) > .tooltipHeaderDescription`
+    ).textContent;
+  }
+
+  // Name
+  Assert.equal(getTooltipDescription(1), TITLE);
+  // Calendar
+  Assert.equal(getTooltipDescription(2), "Test");
+  // Priority
+  Assert.equal(getTooltipDescription(3), "High");
+  // Status
+  Assert.equal(getTooltipDescription(4), "Needs Action");
+  // Complete
+  Assert.equal(getTooltipDescription(5), PERCENTCOMPLETE + "%");
+
+  // Mark completed, verify.
+  EventUtils.synthesizeMouseAtCenter(
+    document.getElementById("task-actions-markcompleted"),
+    {},
+    window
+  );
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(resolve => setTimeout(resolve, MID_SLEEP));
+
+  toolTipNode.ownerGlobal.showToolTip(toolTipNode, taskTreeNode.getTaskAtRow(0));
+  Assert.equal(getTooltipDescription(4), "Completed");
+
+  // Delete task and verify.
+  EventUtils.synthesizeMouseAtCenter(
+    document.getElementById("calendar-delete-task-button"),
+    {},
+    window
+  );
+  await TestUtils.waitForCondition(
+    () => taskTreeNode.mTaskArray.length == 0,
+    "Task did not delete"
+  );
+
+  let tabmail = document.getElementById("tabmail");
+  tabmail.closeTab(tabmail.currentTabInfo);
+
+  Assert.ok(true, "Test ran to completion");
+});
diff --git a/comm/calendar/test/browser/views/browser_viewSwitch.js b/comm/calendar/test/browser/views/browser_viewSwitch.js
new file mode 100644
index 0000000000..e730f3d797
--- /dev/null
+++ b/comm/calendar/test/browser/views/browser_viewSwitch.js
@@ -0,0 +1,138 @@
+/* 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/. */
+
+/**
+ * Tests that the time indicator is restarted and scroll position is restored
+ * when switching tabs or views.
+ */
+
+/**
+ * Wait until the view's timebar shows the given number of visible hours.
+ *
+ * @param {CalendarMultidayBaseView} view - The calendar view.
+ * @param {number} numHours - The expected number of visible hours.
+ *
+ * @returns {Promise} - Promise that resolves when the timebar has numHours
+ *   visible hours.
+ */
+function waitForVisibleHours(view, numHours) {
+  // The timebar is the only scrollable child in its column (the others are
+  // sticky), so the difference between the scroll area's scrollTopMax and the
+  // timebar's clientHeight should give us the visible height.
+  return TestUtils.waitForCondition(() => {
+    let timebarHeight = view.timebar.clientHeight;
+    let visiblePx = timebarHeight - view.grid.scrollTopMax;
+    let expectPx = (numHours / 24) * timebarHeight;
+    // Allow up to 3px difference to accommodate accumulated integer rounding
+    // errors (e.g. clientHeight is a rounded integer, whilst client rectangles
+    // and expectPx are floating).
+    return Math.abs(visiblePx - expectPx) < 3;
+  }, `${view.id} should have ${numHours} hours visible`);
+}
+
+/**
+ * Wait until the view's timebar's first visible hour is the given hour.
+ *
+ * @param {CalendarMultidayBaseView} view - The calendar view.
+ * @param {number} hour - The expected first visible hour.
+ *
+ * @returns {Promise} - Promise that resolves when the timebar has the given
+ *   first visible hour.
+ */
+function waitForFirstVisibleHour(view, hour) {
+  return TestUtils.waitForCondition(() => {
+    let expectPx = (hour / 24) * view.timebar.clientHeight;
+    let actualPx = view.grid.scrollTop;
+    return Math.abs(actualPx - expectPx) < 3;
+  }, `${view.id} first visible hour should be ${hour}`);
+}
+
+/**
+ * Perform a scroll on the view by one hour.
+ *
+ * @param {CalendarMultidayBaseView} view - The calendar view to scroll.
+ * @param {boolean} scrollDown - Whether to scroll down, otherwise scrolls up.
+ */
+async function doScroll(view, scrollDown) {
+  let scrollPromise = BrowserTestUtils.waitForEvent(view.grid, "scroll");
+  let viewRect = view.getBoundingClientRect();
+  EventUtils.synthesizeWheel(
+    view.grid,
+    viewRect.width / 2,
+    viewRect.height / 2,
+    { deltaY: scrollDown ? 1 : -1, deltaMode: WheelEvent.DOM_DELTA_LINE },
+    window
+  );
+  await scrollPromise;
+}
+
+add_task(async function () {
+  let expectedVisibleHours = 3;
+  let expectedStartHour = 3;
+
+  let tabmail = document.getElementById("tabmail");
+  Assert.equal(tabmail.tabInfo.length, 1);
+
+  Assert.equal(Services.prefs.getIntPref("calendar.view.daystarthour"), expectedStartHour);
+  Assert.equal(Services.prefs.getIntPref("calendar.view.dayendhour"), 12);
+  Assert.equal(Services.prefs.getIntPref("calendar.view.visiblehours"), expectedVisibleHours);
+
+  // Open the day view, check the display matches the prefs.
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+
+  let dayView = document.getElementById("day-view");
+
+  await waitForFirstVisibleHour(dayView, expectedStartHour);
+  await waitForVisibleHours(dayView, expectedVisibleHours);
+
+  // Scroll down 3 hours. We'll check this scroll position later.
+  await doScroll(dayView, true);
+  await waitForFirstVisibleHour(dayView, expectedStartHour + 1);
+
+  await doScroll(dayView, true);
+  await doScroll(dayView, true);
+  await waitForFirstVisibleHour(dayView, expectedStartHour + 3);
+  await waitForVisibleHours(dayView, expectedVisibleHours);
+
+  // Open the week view, check the display matches the prefs.
+
+  await CalendarTestUtils.setCalendarView(window, "week");
+
+  let weekView = document.getElementById("week-view");
+
+  await waitForFirstVisibleHour(weekView, expectedStartHour);
+  await waitForVisibleHours(weekView, expectedVisibleHours);
+
+  // Scroll up 1 hour.
+  await doScroll(weekView, false);
+  await waitForFirstVisibleHour(weekView, expectedStartHour - 1);
+  await waitForVisibleHours(weekView, expectedVisibleHours);
+
+  // Go back to the day view, check the timer and scroll position.
+
+  await CalendarTestUtils.setCalendarView(window, "day");
+
+  await waitForFirstVisibleHour(dayView, expectedStartHour + 3);
+  await waitForVisibleHours(dayView, expectedVisibleHours);
+
+  // Switch away from the calendar tab.
+
+  tabmail.switchToTab(0);
+
+  // Switch back to the calendar tab. Check scroll position.
+
+  tabmail.switchToTab(1);
+  Assert.equal(window.currentView().id, "day-view");
+
+  await waitForFirstVisibleHour(dayView, expectedStartHour + 3);
+  await waitForVisibleHours(dayView, expectedVisibleHours);
+
+  // Go back to the week view. Check scroll position.
+
+  await CalendarTestUtils.setCalendarView(window, "week");
+
+  await waitForFirstVisibleHour(weekView, expectedStartHour - 1);
+  await waitForVisibleHours(weekView, expectedVisibleHours);
+});
diff --git a/comm/calendar/test/browser/views/browser_weekView.js b/comm/calendar/test/browser/views/browser_weekView.js
new file mode 100644
index 0000000000..0835da2f23
--- /dev/null
+++ b/comm/calendar/test/browser/views/browser_weekView.js
@@ -0,0 +1,81 @@
+/* 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 { formatDate, formatTime, saveAndCloseItemDialog, setData } = ChromeUtils.import(
+  "resource://testing-common/calendar/ItemEditingHelpers.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+var TITLE1 = "Week View Event";
+var TITLE2 = "Week View Event Changed";
+var DESC = "Week View Event Description";
+
+add_task(async function testWeekView() {
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  await CalendarTestUtils.setCalendarView(window, "week");
+  await CalendarTestUtils.goToDate(window, 2009, 1, 1);
+
+  // Verify date.
+  await TestUtils.waitForCondition(() => {
+    let dateLabel = document.querySelector("#week-view .day-column-selected calendar-event-column");
+    return dateLabel?.date.icalString == "20090101";
+  }, "Date is selected");
+
+  // Create event at 8 AM.
+  // Thursday of 2009-01-05 is 4th with default settings.
+  let eventBox = CalendarTestUtils.weekView.getHourBoxAt(window, 5, 8);
+  let { dialogWindow, iframeWindow, iframeDocument } = await CalendarTestUtils.editNewEvent(
+    window,
+    eventBox
+  );
+
+  // Check that the start time is correct.
+  let someDate = cal.createDateTime();
+  someDate.resetTo(2009, 0, 5, 8, 0, 0, cal.dtz.UTC);
+
+  let startPicker = iframeDocument.getElementById("event-starttime");
+  Assert.equal(startPicker._datepicker._inputField.value, formatDate(someDate));
+  Assert.equal(startPicker._timepicker._inputField.value, formatTime(someDate));
+
+  // Fill in title, description and calendar.
+  await setData(dialogWindow, iframeWindow, {
+    title: TITLE1,
+    description: DESC,
+    calendar: "Test",
+  });
+
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // If it was created successfully, it can be opened.
+  ({ dialogWindow, iframeWindow } = await CalendarTestUtils.weekView.editEventAt(window, 5, 1));
+  // Change title and save changes.
+  await setData(dialogWindow, iframeWindow, { title: TITLE2 });
+  await saveAndCloseItemDialog(dialogWindow);
+
+  // Check if name was saved.
+  let eventName;
+  await TestUtils.waitForCondition(() => {
+    eventBox = CalendarTestUtils.weekView.getEventBoxAt(window, 5, 1);
+    if (!eventBox) {
+      return false;
+    }
+    eventName = eventBox.querySelector(".event-name-label").textContent;
+    return eventName == TITLE2;
+  }, "event name did not update in time");
+
+  Assert.equal(eventName, TITLE2);
+
+  // Delete event.
+  EventUtils.synthesizeMouseAtCenter(eventBox, {}, window);
+  eventBox.focus();
+  EventUtils.synthesizeKey("VK_DELETE", {}, window);
+  await CalendarTestUtils.weekView.waitForNoEventBoxAt(window, 5, 1);
+
+  Assert.ok(true, "Test ran to completion");
+});
diff --git a/comm/calendar/test/browser/views/head.js b/comm/calendar/test/browser/views/head.js
new file mode 100644
index 0000000000..c0f924d9b5
--- /dev/null
+++ b/comm/calendar/test/browser/views/head.js
@@ -0,0 +1,13 @@
+/* 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 { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+const calendarViewsInitialState = CalendarTestUtils.saveCalendarViewsState(window);
+
+registerCleanupFunction(async () => {
+  await CalendarTestUtils.restoreCalendarViewsState(window, calendarViewsInitialState);
+});
diff --git a/comm/calendar/test/moz.build b/comm/calendar/test/moz.build
new file mode 100644
index 0000000000..8c6dc6b9db
--- /dev/null
+++ b/comm/calendar/test/moz.build
@@ -0,0 +1,30 @@
+# vim: set filetype=python:
+# 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/.
+
+BROWSER_CHROME_MANIFESTS += [
+    "browser/browser.ini",
+    "browser/contextMenu/browser.ini",
+    "browser/eventDialog/browser.ini",
+    "browser/invitations/browser.ini",
+    "browser/preferences/browser.ini",
+    "browser/providers/browser.ini",
+    "browser/recurrence/browser.ini",
+    "browser/recurrence/browser_rotated.ini",
+    "browser/timezones/browser.ini",
+    "browser/views/browser.ini",
+]
+
+TESTING_JS_MODULES.calendar += [
+    "CalDAVServer.jsm",
+    "CalendarTestUtils.jsm",
+    "CalendarUtils.jsm",
+    "ICSServer.jsm",
+    "ItemEditingHelpers.jsm",
+]
+
+XPCSHELL_TESTS_MANIFESTS += [
+    "unit/providers/xpcshell.ini",
+    "unit/xpcshell.ini",
+]
diff --git a/comm/calendar/test/unit/data/bug1790339.sql b/comm/calendar/test/unit/data/bug1790339.sql
new file mode 100644
index 0000000000..ad464de995
--- /dev/null
+++ b/comm/calendar/test/unit/data/bug1790339.sql
@@ -0,0 +1,194 @@
+-- Data for test_bug1790339.js. There's two events here, one saved with folded ICAL strings

+-- (as libical would do) and one with unfolded ICAL strings (as ical.js does).

+--

+-- This file contains significant white-space and is deliberately saved with Windows line-endings.

+

+CREATE TABLE cal_calendar_schema_version (version INTEGER);

+CREATE TABLE cal_attendees (

+  item_id TEXT,

+  recurrence_id INTEGER,

+  recurrence_id_tz TEXT,

+  cal_id TEXT,

+  icalString TEXT);

+CREATE TABLE cal_recurrence (item_id TEXT, cal_id TEXT, icalString TEXT);

+CREATE TABLE cal_properties (

+  item_id TEXT,

+  key TEXT,

+  value BLOB,

+  recurrence_id INTEGER,

+  recurrence_id_tz TEXT,

+  cal_id TEXT);

+CREATE TABLE cal_events (

+  cal_id TEXT,

+  id TEXT,

+  time_created INTEGER,

+  last_modified INTEGER,

+  title TEXT,

+  priority INTEGER,

+  privacy TEXT,

+  ical_status TEXT,

+  flags INTEGER,

+  event_start INTEGER,

+  event_end INTEGER,

+  event_stamp INTEGER,

+  event_start_tz TEXT,

+  event_end_tz TEXT,

+  recurrence_id INTEGER,

+  recurrence_id_tz TEXT,

+  alarm_last_ack INTEGER,

+  offline_journal INTEGER);

+CREATE TABLE cal_todos (

+  cal_id TEXT,

+  id TEXT,

+  time_created INTEGER,

+  last_modified INTEGER,

+  title TEXT,

+  priority INTEGER,

+  privacy TEXT,

+  ical_status TEXT,

+  flags INTEGER,

+  todo_entry INTEGER,

+  todo_due INTEGER,

+  todo_completed INTEGER,

+  todo_complete INTEGER,

+  todo_entry_tz TEXT,

+  todo_due_tz TEXT,

+  todo_completed_tz TEXT,

+  recurrence_id INTEGER,

+  recurrence_id_tz TEXT,

+  alarm_last_ack INTEGER,

+  todo_stamp INTEGER,

+  offline_journal INTEGER);

+CREATE TABLE cal_tz_version (version TEXT);

+CREATE TABLE cal_metadata (cal_id TEXT, item_id TEXT, value BLOB);

+CREATE TABLE cal_alarms (

+  cal_id TEXT,

+  item_id TEXT,

+  recurrence_id INTEGER,

+  recurrence_id_tz TEXT,

+  icalString TEXT);

+CREATE TABLE cal_relations (

+  cal_id TEXT,

+  item_id TEXT,

+  recurrence_id INTEGER,

+  recurrence_id_tz TEXT,

+  icalString TEXT);

+CREATE TABLE cal_attachments (

+  item_id TEXT,

+  cal_id TEXT,

+  recurrence_id INTEGER,

+  recurrence_id_tz TEXT,

+  icalString TEXT);

+CREATE TABLE cal_parameters (

+  cal_id TEXT,

+  item_id TEXT,

+  recurrence_id INTEGER,

+  recurrence_id_tz TEXT,

+  key1 TEXT,

+  key2 TEXT,

+  value BLOB);

+

+INSERT INTO cal_calendar_schema_version VALUES (23);

+

+INSERT INTO cal_events (

+  cal_id,

+  id,

+  time_created,

+  last_modified,

+  title,

+  flags,

+  event_start,

+  event_end,

+  event_stamp,

+  event_start_tz,

+  event_end_tz

+) VALUES (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-111111111111',

+  1663028606000000,

+  1663030277000000,

+  'test',

+  86,

+  1663032600000000,

+  1663037100000000,

+  1663030277000000,

+  'Pacific/Auckland',

+  'Pacific/Auckland'

+),  (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-222222222222',

+  1663028606000000,

+  1663030277000000,

+  'test',

+  86,

+  1663032600000000,

+  1663037100000000,

+  1663030277000000,

+  'Pacific/Auckland',

+  'Pacific/Auckland'

+);

+

+INSERT INTO cal_attachments (cal_id, item_id, icalString) VALUES (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-111111111111',

+  'ATTACH:https://ftp.mozilla.org/pub/thunderbird/nightly/latest-comm-central

+ /thunderbird-106.0a1.en-US.linux-x86_64.tar.bz2'

+), (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-222222222222',

+  'ATTACH:https://ftp.mozilla.org/pub/thunderbird/nightly/latest-comm-central/thunderbird-106.0a1.en-US.linux-x86_64.tar.bz2'

+);

+

+INSERT INTO cal_attendees (cal_id, item_id, icalString) VALUES (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-111111111111',

+  'ATTENDEE;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT;CN=Test Person:mailto:

+ test@example.com'

+), (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-222222222222',

+  'ATTENDEE;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT;CN=Test Person:mailto:test@example.com'

+);

+

+INSERT INTO cal_recurrence (cal_id, item_id, icalString) VALUES (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-111111111111',

+  'RRULE:FREQ=WEEKLY;UNTIL=20220913T013000Z;INTERVAL=22;BYDAY=MO,TU,WE,TH,FR,

+ SA,SU'

+), (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-222222222222',

+  'RRULE:FREQ=WEEKLY;UNTIL=20220913T013000Z;INTERVAL=22;BYDAY=MO,TU,WE,TH,FR,SA,SU'

+);

+

+INSERT INTO cal_relations (cal_id, item_id, icalString) VALUES (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-111111111111',

+  'RELATED-TO;RELTYPE=SIBLING:19960401-080045-4000F192713@

+ example.com'

+), (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-222222222222',

+  'RELATED-TO;RELTYPE=SIBLING:19960401-080045-4000F192713@example.com'

+);

+

+INSERT INTO cal_alarms (cal_id, item_id, icalString) VALUES (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-111111111111',

+  'BEGIN:VALARM

+ACTION:DISPLAY

+TRIGGER:-PT5M

+DESCRIPTION:Make sure you don''t miss this very very important event. It''s

+  essential that you don''t forget.

+END:VALARM

+'

+), (

+  '00000000-0000-0000-0000-000000000000',

+  '00000000-0000-0000-0000-222222222222',

+  'BEGIN:VALARM

+ACTION:DISPLAY

+TRIGGER:-PT5M

+DESCRIPTION:Make sure you don''t miss this very very important event. It''s essential that you don''t forget.

+END:VALARM

+'

+);

diff --git a/comm/calendar/test/unit/data/import.ics b/comm/calendar/test/unit/data/import.ics
new file mode 100644
index 0000000000..b6e7a965d7
--- /dev/null
+++ b/comm/calendar/test/unit/data/import.ics
@@ -0,0 +1,24 @@
+BEGIN:VCALENDAR

+PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN

+VERSION:2.0

+BEGIN:VEVENT

+SUMMARY:Event One

+DTSTART:20190101T150000

+DTEND:20190101T160000

+END:VEVENT

+BEGIN:VEVENT

+SUMMARY:Event Four

+DTSTART:20190101T180000

+DTEND:20190101T190000

+END:VEVENT

+BEGIN:VEVENT

+SUMMARY:Event Three

+DTSTART:20190101T170000

+DTEND:20190101T180000

+END:VEVENT

+BEGIN:VEVENT

+SUMMARY:Event Two

+DTSTART:20190101T160000

+DTEND:20190101T170000

+END:VEVENT

+END:VCALENDAR

diff --git a/comm/calendar/test/unit/head.js b/comm/calendar/test/unit/head.js
new file mode 100644
index 0000000000..2b7b9c99fa
--- /dev/null
+++ b/comm/calendar/test/unit/head.js
@@ -0,0 +1,337 @@
+/* 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 { AppConstants } = ChromeUtils.importESModule("resource://gre/modules/AppConstants.sys.mjs");
+var { FileUtils } = ChromeUtils.importESModule("resource://gre/modules/FileUtils.sys.mjs");
+
+var { updateAppInfo } = ChromeUtils.importESModule("resource://testing-common/AppInfo.sys.mjs");
+
+ChromeUtils.defineModuleGetter(this, "NetUtil", "resource://gre/modules/NetUtil.jsm");
+
+updateAppInfo();
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+function createDate(aYear, aMonth, aDay, aHasTime, aHour, aMinute, aSecond, aTimezone) {
+  let date = Cc["@mozilla.org/calendar/datetime;1"].createInstance(Ci.calIDateTime);
+  date.resetTo(
+    aYear,
+    aMonth,
+    aDay,
+    aHour || 0,
+    aMinute || 0,
+    aSecond || 0,
+    aTimezone || cal.dtz.UTC
+  );
+  date.isDate = !aHasTime;
+  return date;
+}
+
+function createEventFromIcalString(icalString) {
+  if (/^BEGIN:VCALENDAR/.test(icalString)) {
+    let parser = Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser);
+    parser.parseString(icalString);
+    let items = parser.getItems();
+    cal.ASSERT(items.length == 1);
+    return items[0].QueryInterface(Ci.calIEvent);
+  }
+  let event = Cc["@mozilla.org/calendar/event;1"].createInstance(Ci.calIEvent);
+  event.icalString = icalString;
+  return event;
+}
+
+function createTodoFromIcalString(icalString) {
+  let todo = Cc["@mozilla.org/calendar/todo;1"].createInstance(Ci.calITodo);
+  todo.icalString = icalString;
+  return todo;
+}
+
+function getMemoryCal() {
+  return Cc["@mozilla.org/calendar/calendar;1?type=memory"].createInstance(
+    Ci.calISyncWriteCalendar
+  );
+}
+
+function getStorageCal() {
+  // Whenever we get the storage calendar we need to request a profile,
+  // otherwise the cleanup functions will not run
+  do_get_profile();
+
+  // create URI
+  let db = Services.dirsvc.get("TmpD", Ci.nsIFile);
+  db.append("test_storage.sqlite");
+  let uri = Services.io.newFileURI(db);
+
+  // Make sure timezone service is initialized
+  Cc["@mozilla.org/calendar/timezone-service;1"].getService(Ci.calIStartupService).startup(null);
+
+  // create storage calendar
+  let stor = Cc["@mozilla.org/calendar/calendar;1?type=storage"].createInstance(
+    Ci.calISyncWriteCalendar
+  );
+  stor.uri = uri;
+  stor.id = cal.getUUID();
+  return stor;
+}
+
+/**
+ * Return an item property as string.
+ *
+ * @param aItem
+ * @param string aProp possible item properties: start, end, duration,
+ *                     generation, title,
+ *                     id, calendar, creationDate, lastModifiedTime,
+ *                     stampTime, priority, privacy, status,
+ *                     alarmLastAck, recurrenceStartDate
+ *                     and any property that can be obtained using getProperty()
+ */
+function getProps(aItem, aProp) {
+  let value = null;
+  switch (aProp) {
+    case "start":
+      value = aItem.startDate || aItem.entryDate || null;
+      break;
+    case "end":
+      value = aItem.endDate || aItem.dueDate || null;
+      break;
+    case "duration":
+      value = aItem.duration || null;
+      break;
+    case "generation":
+      value = aItem.generation;
+      break;
+    case "title":
+      value = aItem.title;
+      break;
+    case "id":
+      value = aItem.id;
+      break;
+    case "calendar":
+      value = aItem.calendar.id;
+      break;
+    case "creationDate":
+      value = aItem.creationDate;
+      break;
+    case "lastModifiedTime":
+      value = aItem.lastModifiedTime;
+      break;
+    case "stampTime":
+      value = aItem.stampTime;
+      break;
+    case "priority":
+      value = aItem.priority;
+      break;
+    case "privacy":
+      value = aItem.privacy;
+      break;
+    case "status":
+      value = aItem.status;
+      break;
+    case "alarmLastAck":
+      value = aItem.alarmLastAck;
+      break;
+    case "recurrenceStartDate":
+      value = aItem.recurrenceStartDate;
+      break;
+    default:
+      value = aItem.getProperty(aProp);
+  }
+  if (value) {
+    return value.toString();
+  }
+  return null;
+}
+
+function compareItemsSpecific(aLeftItem, aRightItem, aPropArray) {
+  if (!aPropArray) {
+    // left out:  "id", "calendar", "lastModifiedTime", "generation",
+    // "stampTime" as these are expected to change
+    aPropArray = [
+      "start",
+      "end",
+      "duration",
+      "title",
+      "priority",
+      "privacy",
+      "creationDate",
+      "status",
+      "alarmLastAck",
+      "recurrenceStartDate",
+    ];
+  }
+  if (aLeftItem instanceof Ci.calIEvent) {
+    aLeftItem.QueryInterface(Ci.calIEvent);
+  } else if (aLeftItem instanceof Ci.calITodo) {
+    aLeftItem.QueryInterface(Ci.calITodo);
+  }
+  for (let i = 0; i < aPropArray.length; i++) {
+    equal(getProps(aLeftItem, aPropArray[i]), getProps(aRightItem, aPropArray[i]));
+  }
+}
+
+/**
+ * Unfold ics lines by removing any \r\n or \n followed by a linear whitespace
+ * (space or htab).
+ *
+ * @param aLine     The line to unfold
+ * @returns The unfolded line
+ */
+function ics_unfoldline(aLine) {
+  return aLine.replace(/\r?\n[ \t]/g, "");
+}
+
+/**
+ * Dedent the template string tagged with this function to make indented data
+ * easier to read. Usage:
+ *
+ * let data = dedent`
+ *     This is indented data it will be unindented so that the first line has
+ *       no leading spaces and the second is indented by two spaces.
+ * `;
+ *
+ * @param strings       The string fragments from the template string
+ * @param ...values     The interpolated values
+ * @returns The interpolated, dedented string
+ */
+function dedent(strings, ...values) {
+  let parts = [];
+  // Perform variable interpolation
+  let minIndent = Infinity;
+  for (let [i, string] of strings.entries()) {
+    let innerparts = string.split("\n");
+    if (i == 0) {
+      innerparts.shift();
+    }
+    if (i == strings.length - 1) {
+      innerparts.pop();
+    }
+    for (let [j, ip] of innerparts.entries()) {
+      let match = ip.match(/^(\s*)\S*/);
+      if (j != 0) {
+        minIndent = Math.min(minIndent, match[1].length);
+      }
+    }
+    parts.push(innerparts);
+  }
+
+  return parts
+    .map((part, i) => {
+      return (
+        part
+          .map((line, j) => {
+            return j == 0 && i > 0 ? line : line.substr(minIndent);
+          })
+          .join("\n") + (i < values.length ? values[i] : "")
+      );
+    })
+    .join("");
+}
+
+/**
+ * Read a JSON file and return the JS object
+ */
+function readJSONFile(aFile) {
+  let stream = Cc["@mozilla.org/network/file-input-stream;1"].createInstance(Ci.nsIFileInputStream);
+  try {
+    stream.init(aFile, FileUtils.MODE_RDONLY, FileUtils.PERMS_FILE, 0);
+    let bytes = NetUtil.readInputStream(stream, stream.available());
+    let data = JSON.parse(new TextDecoder().decode(bytes));
+    return data;
+  } catch (ex) {
+    dump("readJSONFile: Error reading JSON file: " + ex);
+  } finally {
+    stream.close();
+  }
+  return false;
+}
+
+function do_load_timezoneservice(callback) {
+  do_test_pending();
+  cal.timezoneService.startup({
+    onResult() {
+      do_test_finished();
+      callback();
+    },
+  });
+}
+
+function do_load_calmgr(callback) {
+  do_test_pending();
+  cal.manager.startup({
+    onResult() {
+      do_test_finished();
+      callback();
+    },
+  });
+}
+
+function do_calendar_startup(callback) {
+  let obs = {
+    observe() {
+      Services.obs.removeObserver(this, "calendar-startup-done");
+      do_test_finished();
+      executeSoon(callback);
+    },
+  };
+
+  let startupService = Cc["@mozilla.org/calendar/startup-service;1"].getService(
+    Ci.nsISupports
+  ).wrappedJSObject;
+
+  if (startupService.started) {
+    callback();
+  } else {
+    do_test_pending();
+    Services.obs.addObserver(obs, "calendar-startup-done");
+    if (this._profileInitialized) {
+      Services.obs.notifyObservers(null, "profile-after-change", "xpcshell-do-get-profile");
+    } else {
+      do_get_profile(true);
+    }
+  }
+}
+
+/**
+ * Monkey patch the function with the name x on obj and overwrite it with func.
+ * The first parameter of this function is the original function that can be
+ * called at any time.
+ *
+ * @param obj           The object the function is on.
+ * @param name          The string name of the function.
+ * @param func          The function to monkey patch with.
+ */
+function monkeyPatch(obj, x, func) {
+  let old = obj[x];
+  obj[x] = function () {
+    let parent = old.bind(obj);
+    let args = Array.from(arguments);
+    args.unshift(parent);
+    try {
+      return func.apply(obj, args);
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  };
+}
+
+/**
+ * Asserts the properties of an actual extract parser result to what was
+ * expected.
+ *
+ * @param {object} actual - Mostly the actual output of parse().
+ * @param {object} expected - The expected output.
+ * @param {string} level - The variable name to refer to report on.
+ */
+function compareExtractResults(actual, expected, level = "") {
+  for (let [key, value] of Object.entries(expected)) {
+    let qualifiedKey = [level, Array.isArray(expected) ? `[${key}]` : `.${key}`].join("");
+    if (value && typeof value == "object") {
+      Assert.ok(actual[key], `${qualifiedKey} is not null`);
+      compareExtractResults(actual[key], value, qualifiedKey);
+      continue;
+    }
+    Assert.equal(actual[key], value, `${qualifiedKey} has value "${value}"`);
+  }
+}
diff --git a/comm/calendar/test/unit/providers/head.js b/comm/calendar/test/unit/providers/head.js
new file mode 100644
index 0000000000..3c995ab31a
--- /dev/null
+++ b/comm/calendar/test/unit/providers/head.js
@@ -0,0 +1,152 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+var { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+var { PromiseUtils } = ChromeUtils.importESModule("resource://gre/modules/PromiseUtils.sys.mjs");
+
+var { updateAppInfo } = ChromeUtils.importESModule("resource://testing-common/AppInfo.sys.mjs");
+updateAppInfo();
+
+// The tests in this directory each do the same thing, with slight variations as needed for each
+// calendar provider. The core of the test lives in this file and the tests call it when ready.
+
+do_get_profile();
+add_setup(async () => {
+  await new Promise(resolve => cal.manager.startup({ onResult: resolve }));
+  await new Promise(resolve => cal.timezoneService.startup({ onResult: resolve }));
+  cal.manager.addCalendarObserver(calendarObserver);
+});
+
+let calendarObserver = {
+  QueryInterface: ChromeUtils.generateQI(["calIObserver"]),
+
+  /* calIObserver */
+
+  _batchCount: 0,
+  _batchRequired: true,
+  onStartBatch(calendar) {
+    info(`onStartBatch ${calendar?.id} ${++this._batchCount}`);
+    Assert.equal(calendar, this._expectedCalendar);
+    Assert.equal(this._batchCount, 1, "onStartBatch must not occur in a batch");
+  },
+  onEndBatch(calendar) {
+    info(`onEndBatch ${calendar?.id} ${this._batchCount--}`);
+    Assert.equal(calendar, this._expectedCalendar);
+    Assert.equal(this._batchCount, 0, "onEndBatch must occur in a batch");
+  },
+  onLoad(calendar) {
+    info(`onLoad ${calendar.id}`);
+    Assert.equal(this._batchCount, 0, "onLoad must not occur in a batch");
+    Assert.equal(calendar, this._expectedCalendar);
+    if (this._onLoadPromise) {
+      this._onLoadPromise.resolve();
+    }
+  },
+  onAddItem(item) {
+    info(`onAddItem ${item.calendar.id} ${item.id}`);
+    if (this._batchRequired) {
+      Assert.equal(this._batchCount, 1, "onAddItem must occur in a batch");
+    }
+    if (this._onAddItemPromise) {
+      this._onAddItemPromise.resolve();
+    }
+  },
+  onModifyItem(newItem, oldItem) {
+    info(`onModifyItem ${newItem.calendar.id} ${newItem.id}`);
+    if (this._batchRequired) {
+      Assert.equal(this._batchCount, 1, "onModifyItem must occur in a batch");
+    }
+    if (this._onModifyItemPromise) {
+      this._onModifyItemPromise.resolve();
+    }
+  },
+  onDeleteItem(deletedItem) {
+    info(`onDeleteItem ${deletedItem.calendar.id} ${deletedItem.id}`);
+    if (this._onDeleteItemPromise) {
+      this._onDeleteItemPromise.resolve();
+    }
+  },
+  onError(calendar, errNo, message) {},
+  onPropertyChanged(calendar, name, value, oldValue) {},
+  onPropertyDeleting(calendar, name) {},
+};
+
+/**
+ * Create and register a calendar.
+ *
+ * @param {string} type - The calendar provider to use.
+ * @param {string} url - URL of the server.
+ * @param {boolean} useCache - Should this calendar have offline storage?
+ * @returns {calICalendar}
+ */
+function createCalendar(type, url, useCache) {
+  let calendar = cal.manager.createCalendar(type, Services.io.newURI(url));
+  calendar.name = type + (useCache ? " with cache" : " without cache");
+  calendar.id = cal.getUUID();
+  calendar.setProperty("cache.enabled", useCache);
+
+  cal.manager.registerCalendar(calendar);
+  calendar = cal.manager.getCalendarById(calendar.id);
+  calendarObserver._expectedCalendar = calendar;
+
+  info(`Created calendar ${calendar.id}`);
+  return calendar;
+}
+
+/**
+ * Creates an event and adds it to the given calendar.
+ *
+ * @param {calICalendar} calendar
+ * @returns {calIEvent}
+ */
+async function runAddItem(calendar) {
+  let event = new CalEvent();
+  event.id = "6b7dd6f6-d6f0-4e93-a953-bb5473c4c47a";
+  event.title = "New event";
+  event.startDate = cal.createDateTime("20200303T205500Z");
+  event.endDate = cal.createDateTime("20200303T210200Z");
+
+  calendarObserver._onAddItemPromise = PromiseUtils.defer();
+  calendarObserver._onModifyItemPromise = PromiseUtils.defer();
+  await calendar.addItem(event);
+  await Promise.any([
+    calendarObserver._onAddItemPromise.promise,
+    calendarObserver._onModifyItemPromise.promise,
+  ]);
+
+  return event;
+}
+
+/**
+ * Modifies the event from runAddItem.
+ *
+ * @param {calICalendar} calendar
+ */
+async function runModifyItem(calendar) {
+  let event = await calendar.getItem("6b7dd6f6-d6f0-4e93-a953-bb5473c4c47a");
+
+  let clone = event.clone();
+  clone.title = "Modified event";
+
+  calendarObserver._onModifyItemPromise = PromiseUtils.defer();
+  await calendar.modifyItem(clone, event);
+  await calendarObserver._onModifyItemPromise.promise;
+}
+
+/**
+ * Deletes the event from runAddItem.
+ *
+ * @param {calICalendar} calendar
+ */
+async function runDeleteItem(calendar) {
+  let event = await calendar.getItem("6b7dd6f6-d6f0-4e93-a953-bb5473c4c47a");
+
+  calendarObserver._onDeleteItemPromise = PromiseUtils.defer();
+  await calendar.deleteItem(event);
+  await calendarObserver._onDeleteItemPromise.promise;
+}
diff --git a/comm/calendar/test/unit/providers/test_caldavCalendar_cached.js b/comm/calendar/test/unit/providers/test_caldavCalendar_cached.js
new file mode 100644
index 0000000000..7a61973644
--- /dev/null
+++ b/comm/calendar/test/unit/providers/test_caldavCalendar_cached.js
@@ -0,0 +1,201 @@
+/* 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 { CalDAVServer } = ChromeUtils.import("resource://testing-common/calendar/CalDAVServer.jsm");
+
+add_setup(async function () {
+  CalDAVServer.open();
+  await CalDAVServer.putItemInternal(
+    "5a9fa76c-93f3-4ad8-9f00-9e52aedd2821.ics",
+    CalendarTestUtils.dedent`
+      BEGIN:VCALENDAR
+      BEGIN:VEVENT
+      UID:5a9fa76c-93f3-4ad8-9f00-9e52aedd2821
+      SUMMARY:exists before time
+      DTSTART:20210401T120000Z
+      DTEND:20210401T130000Z
+      END:VEVENT
+      END:VCALENDAR
+      `
+  );
+});
+registerCleanupFunction(() => CalDAVServer.close());
+
+add_task(async function () {
+  calendarObserver._onAddItemPromise = PromiseUtils.defer();
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  let calendar = createCalendar("caldav", CalDAVServer.url, true);
+  await calendarObserver._onAddItemPromise.promise;
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  Assert.ok(await calendar.getItem("5a9fa76c-93f3-4ad8-9f00-9e52aedd2821"));
+
+  info("creating the item");
+  calendarObserver._batchRequired = true;
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  await runAddItem(calendar);
+  await calendarObserver._onLoadPromise.promise;
+
+  info("modifying the item");
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  await runModifyItem(calendar);
+  await calendarObserver._onLoadPromise.promise;
+
+  info("deleting the item");
+  await runDeleteItem(calendar);
+
+  cal.manager.unregisterCalendar(calendar);
+});
+
+/**
+ * Tests calendars that return status 404 for "current-user-privilege-set" are
+ * not flagged read-only.
+ */
+add_task(async function testCalendarWithNoPrivSupport() {
+  CalDAVServer.privileges = null;
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+
+  let calendar = createCalendar("caldav", CalDAVServer.url, true);
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  Assert.ok(!calendar.readOnly, "calendar was not marked read-only");
+
+  cal.manager.unregisterCalendar(calendar);
+});
+
+/**
+ * Tests modifyItem() does not hang when the server reports no actual
+ * modifications were made.
+ */
+add_task(async function testModifyItemWithNoChanges() {
+  let event = new CalEvent();
+  let calendar = createCalendar("caldav", CalDAVServer.url, false);
+  event.id = "6f6dd7b6-0fbd-39e4-359a-a74c4c3745bb";
+  event.title = "A New Event";
+  event.startDate = cal.createDateTime("20200303T205500Z");
+  event.endDate = cal.createDateTime("20200303T210200Z");
+  await calendar.addItem(event);
+
+  let clone = event.clone();
+  clone.title = "A Modified Event";
+
+  let putItemInternal = CalDAVServer.putItemInternal;
+  CalDAVServer.putItemInternal = () => {};
+
+  let modifiedEvent = await calendar.modifyItem(clone, event);
+  CalDAVServer.putItemInternal = putItemInternal;
+
+  Assert.ok(modifiedEvent, "an event was returned");
+  Assert.equal(modifiedEvent.title, event.title, "the un-modified event is returned");
+
+  await calendar.deleteItem(modifiedEvent);
+  cal.manager.unregisterCalendar(calendar);
+});
+
+/**
+ * Tests that an error response from the server when syncing doesn't delete
+ * items from the local calendar.
+ */
+add_task(async function testSyncError1() {
+  calendarObserver._onAddItemPromise = PromiseUtils.defer();
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  let calendar = createCalendar("caldav", CalDAVServer.url, true);
+  await calendarObserver._onAddItemPromise.promise;
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  Assert.ok(
+    await calendar.getItem("5a9fa76c-93f3-4ad8-9f00-9e52aedd2821"),
+    "item should exist when first connected"
+  );
+
+  info("syncing with rate limit error");
+  CalDAVServer.throwRateLimitErrors = true;
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  calendar.refresh();
+  await calendarObserver._onLoadPromise.promise;
+  CalDAVServer.throwRateLimitErrors = false;
+  info("sync with rate limit error complete");
+
+  Assert.equal(
+    calendar.getProperty("currentStatus"),
+    Cr.NS_OK,
+    "calendar should not be in an error state"
+  );
+  Assert.equal(calendar.getProperty("disabled"), null, "calendar should not be disabled");
+  Assert.ok(
+    await calendar.getItem("5a9fa76c-93f3-4ad8-9f00-9e52aedd2821"),
+    "item should still exist after error response"
+  );
+
+  info("syncing without rate limit error");
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  calendar.refresh();
+  await calendarObserver._onLoadPromise.promise;
+  info("sync without rate limit error complete");
+
+  Assert.ok(
+    await calendar.getItem("5a9fa76c-93f3-4ad8-9f00-9e52aedd2821"),
+    "item should still exist after successful sync"
+  );
+
+  cal.manager.unregisterCalendar(calendar);
+});
+
+/**
+ * Tests that multiple pages of item responses from the server when syncing
+ * doesn't result in items being deleted from the local calendar.
+ *
+ * The server has a page size of 3, although this test should pass regardless
+ * of the page size.
+ */
+add_task(async function testSyncError2() {
+  // Add some items to the server so multiple requests are required to get
+  // them all. There's already one item on the server.
+  for (let i = 0; i < 3; i++) {
+    await CalDAVServer.putItemInternal(
+      `fake-uid-${i}.ics`,
+      CalendarTestUtils.dedent`
+        BEGIN:VCALENDAR
+        BEGIN:VEVENT
+        UID:fake-uid-${i}
+        SUMMARY:event ${i}
+        DTSTART:20210401T120000Z
+        DTEND:20210401T130000Z
+        END:VEVENT
+        END:VCALENDAR
+        `
+    );
+  }
+
+  calendarObserver._onAddItemPromise = PromiseUtils.defer();
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  let calendar = createCalendar("caldav", CalDAVServer.url, true);
+  await calendarObserver._onAddItemPromise.promise;
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  let items = await calendar.getItemsAsArray(Ci.calICalendar.ITEM_FILTER_TYPE_ALL, 0, null, null);
+  Assert.equal(items.length, 4, "all items added to calendar when first connected");
+
+  info("forced syncing with multiple pages");
+  calendar.wrappedJSObject.mUncachedCalendar.wrappedJSObject.mWebdavSyncToken = null;
+  calendar.wrappedJSObject.mUncachedCalendar.wrappedJSObject.saveCalendarProperties();
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  calendar.refresh();
+  await calendarObserver._onLoadPromise.promise;
+  info("forced sync with multiple pages complete");
+
+  items = await calendar.getItemsAsArray(Ci.calICalendar.ITEM_FILTER_TYPE_ALL, 0, null, null);
+  Assert.equal(items.length, 4, "all items still in calendar after forced refresh");
+
+  cal.manager.unregisterCalendar(calendar);
+
+  // Delete the added items.
+  for (let i = 0; i < 3; i++) {
+    CalDAVServer.deleteItemInternal(`fake-uid-${i}.ics`);
+  }
+});
diff --git a/comm/calendar/test/unit/providers/test_caldavCalendar_uncached.js b/comm/calendar/test/unit/providers/test_caldavCalendar_uncached.js
new file mode 100644
index 0000000000..025a1ba871
--- /dev/null
+++ b/comm/calendar/test/unit/providers/test_caldavCalendar_uncached.js
@@ -0,0 +1,96 @@
+/* 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 { CalDAVServer } = ChromeUtils.import("resource://testing-common/calendar/CalDAVServer.jsm");
+
+add_setup(async function () {
+  CalDAVServer.open();
+  await CalDAVServer.putItemInternal(
+    "5a9fa76c-93f3-4ad8-9f00-9e52aedd2821.ics",
+    CalendarTestUtils.dedent`
+      BEGIN:VCALENDAR
+      BEGIN:VEVENT
+      UID:5a9fa76c-93f3-4ad8-9f00-9e52aedd2821
+      SUMMARY:exists before time
+      DTSTART:20210401T120000Z
+      DTEND:20210401T130000Z
+      END:VEVENT
+      END:VCALENDAR
+      `
+  );
+});
+registerCleanupFunction(() => CalDAVServer.close());
+
+add_task(async function () {
+  calendarObserver._onAddItemPromise = PromiseUtils.defer();
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  let calendar = createCalendar("caldav", CalDAVServer.url, false);
+  await calendarObserver._onAddItemPromise.promise;
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  Assert.ok(await calendar.getItem("5a9fa76c-93f3-4ad8-9f00-9e52aedd2821"));
+
+  info("creating the item");
+  calendarObserver._batchRequired = true;
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  await runAddItem(calendar);
+  await calendarObserver._onLoadPromise.promise;
+
+  info("modifying the item");
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  await runModifyItem(calendar);
+  await calendarObserver._onLoadPromise.promise;
+
+  info("deleting the item");
+  await runDeleteItem(calendar);
+
+  cal.manager.unregisterCalendar(calendar);
+});
+
+/**
+ * Tests calendars that return status 404 for "current-user-privilege-set" are
+ * not flagged read-only.
+ */
+add_task(async function testCalendarWithNoPrivSupport() {
+  CalDAVServer.privileges = null;
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+
+  let calendar = createCalendar("caldav", CalDAVServer.url, false);
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  Assert.ok(!calendar.readOnly, "calendar was not marked read-only");
+
+  cal.manager.unregisterCalendar(calendar);
+});
+
+/**
+ * Tests modifyItem() does not hang when the server reports no actual
+ * modifications were made.
+ */
+add_task(async function testModifyItemWithNoChanges() {
+  let event = new CalEvent();
+  let calendar = createCalendar("caldav", CalDAVServer.url, false);
+  event.id = "6f6dd7b6-0fbd-39e4-359a-a74c4c3745bb";
+  event.title = "A New Event";
+  event.startDate = cal.createDateTime("20200303T205500Z");
+  event.endDate = cal.createDateTime("20200303T210200Z");
+  await calendar.addItem(event);
+
+  let clone = event.clone();
+  clone.title = "A Modified Event";
+
+  let putItemInternal = CalDAVServer.putItemInternal;
+  CalDAVServer.putItemInternal = () => {};
+
+  let modifiedEvent = await calendar.modifyItem(clone, event);
+  CalDAVServer.putItemInternal = putItemInternal;
+
+  Assert.ok(modifiedEvent, "an event was returned");
+  Assert.equal(modifiedEvent.title, event.title, "the un-modified event is returned");
+
+  await calendar.deleteItem(modifiedEvent);
+  cal.manager.unregisterCalendar(calendar);
+});
diff --git a/comm/calendar/test/unit/providers/test_icsCalendar_cached.js b/comm/calendar/test/unit/providers/test_icsCalendar_cached.js
new file mode 100644
index 0000000000..9bc1b127da
--- /dev/null
+++ b/comm/calendar/test/unit/providers/test_icsCalendar_cached.js
@@ -0,0 +1,53 @@
+/* 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 { ICSServer } = ChromeUtils.import("resource://testing-common/calendar/ICSServer.jsm");
+
+ICSServer.open();
+ICSServer.putICSInternal(
+  CalendarTestUtils.dedent`
+    BEGIN:VCALENDAR
+    BEGIN:VEVENT
+    UID:5a9fa76c-93f3-4ad8-9f00-9e52aedd2821
+    SUMMARY:exists before time
+    DTSTART:20210401T120000Z
+    DTEND:20210401T130000Z
+    END:VEVENT
+    END:VCALENDAR
+    `
+);
+registerCleanupFunction(() => ICSServer.close());
+
+add_task(async function () {
+  // TODO: item notifications from a cached ICS calendar occur outside of batches.
+  // This isn't fatal but it shouldn't happen. Side-effects include alarms firing
+  // twice - once from onAddItem then again at onLoad.
+  //
+  // Remove the next line when this is fixed.
+  calendarObserver._batchRequired = false;
+
+  calendarObserver._onAddItemPromise = PromiseUtils.defer();
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  let calendar = createCalendar("ics", ICSServer.url, true);
+  await calendarObserver._onAddItemPromise.promise;
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  Assert.ok(await calendar.getItem("5a9fa76c-93f3-4ad8-9f00-9e52aedd2821"));
+
+  info("creating the item");
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  await runAddItem(calendar);
+  await calendarObserver._onLoadPromise.promise;
+
+  info("modifying the item");
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  await runModifyItem(calendar);
+  await calendarObserver._onLoadPromise.promise;
+
+  info("deleting the item");
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  await runDeleteItem(calendar);
+  await calendarObserver._onLoadPromise.promise;
+});
diff --git a/comm/calendar/test/unit/providers/test_icsCalendar_uncached.js b/comm/calendar/test/unit/providers/test_icsCalendar_uncached.js
new file mode 100644
index 0000000000..db5db6e99f
--- /dev/null
+++ b/comm/calendar/test/unit/providers/test_icsCalendar_uncached.js
@@ -0,0 +1,46 @@
+/* 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 { ICSServer } = ChromeUtils.import("resource://testing-common/calendar/ICSServer.jsm");
+
+ICSServer.open();
+ICSServer.putICSInternal(
+  CalendarTestUtils.dedent`
+    BEGIN:VCALENDAR
+    BEGIN:VEVENT
+    UID:5a9fa76c-93f3-4ad8-9f00-9e52aedd2821
+    SUMMARY:exists before time
+    DTSTART:20210401T120000Z
+    DTEND:20210401T130000Z
+    END:VEVENT
+    END:VCALENDAR
+    `
+);
+registerCleanupFunction(() => ICSServer.close());
+
+add_task(async function () {
+  calendarObserver._onAddItemPromise = PromiseUtils.defer();
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  let calendar = createCalendar("ics", ICSServer.url, false);
+  await calendarObserver._onAddItemPromise.promise;
+  await calendarObserver._onLoadPromise.promise;
+  info("calendar set-up complete");
+
+  Assert.ok(await calendar.getItem("5a9fa76c-93f3-4ad8-9f00-9e52aedd2821"));
+
+  info("creating the item");
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  await runAddItem(calendar);
+  await calendarObserver._onLoadPromise.promise;
+
+  info("modifying the item");
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  await runModifyItem(calendar);
+  await calendarObserver._onLoadPromise.promise;
+
+  info("deleting the item");
+  calendarObserver._onLoadPromise = PromiseUtils.defer();
+  await runDeleteItem(calendar);
+  await calendarObserver._onLoadPromise.promise;
+});
diff --git a/comm/calendar/test/unit/providers/test_storageCalendar.js b/comm/calendar/test/unit/providers/test_storageCalendar.js
new file mode 100644
index 0000000000..778f9f9251
--- /dev/null
+++ b/comm/calendar/test/unit/providers/test_storageCalendar.js
@@ -0,0 +1,17 @@
+/* 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 function () {
+  let calendar = createCalendar("storage", "moz-storage-calendar://");
+
+  info("creating the item");
+  calendarObserver._batchRequired = false;
+  await runAddItem(calendar);
+
+  info("modifying the item");
+  await runModifyItem(calendar);
+
+  info("deleting the item");
+  await runDeleteItem(calendar);
+});
diff --git a/comm/calendar/test/unit/providers/xpcshell.ini b/comm/calendar/test/unit/providers/xpcshell.ini
new file mode 100644
index 0000000000..272fef7c78
--- /dev/null
+++ b/comm/calendar/test/unit/providers/xpcshell.ini
@@ -0,0 +1,11 @@
+[default]
+head = head.js
+prefs =
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+
+[test_caldavCalendar_cached.js]
+[test_caldavCalendar_uncached.js]
+[test_icsCalendar_cached.js]
+[test_icsCalendar_uncached.js]
+[test_storageCalendar.js]
diff --git a/comm/calendar/test/unit/test_CalendarFileImporter.js b/comm/calendar/test/unit/test_CalendarFileImporter.js
new file mode 100644
index 0000000000..358a82942d
--- /dev/null
+++ b/comm/calendar/test/unit/test_CalendarFileImporter.js
@@ -0,0 +1,46 @@
+/* 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 https://mozilla.org/MPL/2.0/. */
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+var { CalendarFileImporter } = ChromeUtils.import("resource:///modules/CalendarFileImporter.jsm");
+
+/**
+ * Test CalendarFileImporter can import ics file correctly.
+ */
+async function test_importIcsFile() {
+  let importer = new CalendarFileImporter();
+
+  // Parse items from ics file should work.
+  let items = await importer.parseIcsFile(do_get_file("data/import.ics"));
+  equal(items.length, 4);
+
+  // Create a temporary calendar.
+  let calendar = CalendarTestUtils.createCalendar();
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  // Put items to the temporary calendar should work.
+  await importer.startImport(items, calendar);
+  let result = await calendar.getItemsAsArray(
+    Ci.calICalendar.ITEM_FILTER_ALL_ITEMS,
+    0,
+    cal.createDateTime("20190101T000000"),
+    cal.createDateTime("20190102T000000")
+  );
+  equal(result.length, 4);
+}
+
+function run_test() {
+  do_get_profile();
+
+  add_test(() => {
+    do_calendar_startup(async () => {
+      await test_importIcsFile();
+      run_next_test();
+    });
+  });
+}
diff --git a/comm/calendar/test/unit/test_alarm.js b/comm/calendar/test/unit/test_alarm.js
new file mode 100644
index 0000000000..14b2ce76bd
--- /dev/null
+++ b/comm/calendar/test/unit/test_alarm.js
@@ -0,0 +1,674 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAlarm: "resource:///modules/CalAlarm.jsm",
+  CalAttachment: "resource:///modules/CalAttachment.jsm",
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+  CalTodo: "resource:///modules/CalTodo.jsm",
+});
+
+function run_tests() {
+  test_initial_creation();
+
+  test_display_alarm();
+  test_email_alarm();
+  test_audio_alarm();
+  test_custom_alarm();
+  test_repeat();
+  test_xprop();
+
+  test_dates();
+
+  test_clone();
+  test_immutable();
+  test_serialize();
+  test_strings();
+}
+
+function run_test() {
+  do_calendar_startup(run_tests);
+}
+
+function test_initial_creation() {
+  dump("Testing initial creation...");
+  let alarm = new CalAlarm();
+
+  let passed;
+  try {
+    // eslint-disable-next-line no-unused-expressions
+    alarm.icalString;
+    passed = false;
+  } catch (e) {
+    passed = true;
+  }
+  if (!passed) {
+    do_throw("Fresh calIAlarm should not produce a valid icalString");
+  }
+  dump("Done\n");
+}
+
+function test_display_alarm() {
+  dump("Testing DISPLAY alarms...");
+  let alarm = new CalAlarm();
+  // Set ACTION to DISPLAY, make sure this was not rejected
+  alarm.action = "DISPLAY";
+  equal(alarm.action, "DISPLAY");
+
+  // Set a Description, REQUIRED for ACTION:DISPLAY
+  alarm.description = "test";
+  equal(alarm.description, "test");
+
+  // SUMMARY is not valid for ACTION:DISPLAY
+  alarm.summary = "test";
+  equal(alarm.summary, null);
+
+  // No attendees allowed
+  let attendee = new CalAttendee();
+  attendee.id = "mailto:horst";
+
+  throws(() => {
+    // DISPLAY alarm should not be able to save attendees
+    alarm.addAttendee(attendee);
+  }, /Alarm type AUDIO\/DISPLAY may not have attendees/);
+
+  throws(() => {
+    // DISPLAY alarm should not be able to save attachment
+    alarm.addAttachment(new CalAttachment());
+  }, /Alarm type DISPLAY may not have attachments/);
+
+  dump("Done\n");
+}
+
+function test_email_alarm() {
+  dump("Testing EMAIL alarms...");
+  let alarm = new CalAlarm();
+  // Set ACTION to DISPLAY, make sure this was not rejected
+  alarm.action = "EMAIL";
+  equal(alarm.action, "EMAIL");
+
+  // Set a Description, REQUIRED for ACTION:EMAIL
+  alarm.description = "description";
+  equal(alarm.description, "description");
+
+  // Set a Summary, REQUIRED for ACTION:EMAIL
+  alarm.summary = "summary";
+  equal(alarm.summary, "summary");
+
+  // Set an offset of some sort
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_START;
+  alarm.offset = cal.createDuration();
+
+  // Check for at least one attendee
+  let attendee1 = new CalAttendee();
+  attendee1.id = "mailto:horst";
+  let attendee2 = new CalAttendee();
+  attendee2.id = "mailto:gustav";
+
+  equal(alarm.getAttendees().length, 0);
+  alarm.addAttendee(attendee1);
+  equal(alarm.getAttendees().length, 1);
+  alarm.addAttendee(attendee2);
+  equal(alarm.getAttendees().length, 2);
+  alarm.addAttendee(attendee1);
+  let addedAttendees = alarm.getAttendees();
+  equal(addedAttendees.length, 2);
+  equal(addedAttendees[0].wrappedJSObject, attendee2);
+  equal(addedAttendees[1].wrappedJSObject, attendee1);
+
+  ok(!!alarm.icalComponent.serializeToICS().match(/mailto:horst/));
+  ok(!!alarm.icalComponent.serializeToICS().match(/mailto:gustav/));
+
+  alarm.deleteAttendee(attendee1);
+  equal(alarm.getAttendees().length, 1);
+
+  alarm.clearAttendees();
+  equal(alarm.getAttendees().length, 0);
+
+  // Make sure attendees are correctly folded/imported
+  alarm.icalString = dedent`
+        BEGIN:VALARM
+        ACTION:EMAIL
+        TRIGGER;VALUE=DURATION:-PT5M
+        ATTENDEE:mailto:test@example.com
+        ATTENDEE:mailto:test@example.com
+        ATTENDEE:mailto:test2@example.com
+        END:VALARM
+    `;
+  equal(alarm.icalString.match(/ATTENDEE:mailto:test@example.com/g).length, 1);
+  equal(alarm.icalString.match(/ATTENDEE:mailto:test2@example.com/g).length, 1);
+
+  // TODO test attachments
+  dump("Done\n");
+}
+
+function test_audio_alarm() {
+  dump("Testing AUDIO alarms...");
+  let alarm = new CalAlarm();
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_ABSOLUTE;
+  alarm.alarmDate = cal.createDateTime();
+  // Set ACTION to AUDIO, make sure this was not rejected
+  alarm.action = "AUDIO";
+  equal(alarm.action, "AUDIO");
+
+  // No Description for ACTION:AUDIO
+  alarm.description = "description";
+  equal(alarm.description, null);
+
+  // No Summary, for ACTION:AUDIO
+  alarm.summary = "summary";
+  equal(alarm.summary, null);
+
+  // No attendees allowed
+  let attendee = new CalAttendee();
+  attendee.id = "mailto:horst";
+
+  try {
+    alarm.addAttendee(attendee);
+    do_throw("AUDIO alarm should not be able to save attendees");
+  } catch (e) {
+    // TODO looks like this test is disabled. Why?
+  }
+
+  // Test attachments
+  let sound = new CalAttachment();
+  sound.uri = Services.io.newURI("file:///sound.wav");
+  let sound2 = new CalAttachment();
+  sound2.uri = Services.io.newURI("file:///sound2.wav");
+
+  // Adding an attachment should work
+  alarm.addAttachment(sound);
+  let addedAttachments = alarm.getAttachments();
+  equal(addedAttachments.length, 1);
+  equal(addedAttachments[0].wrappedJSObject, sound);
+  ok(alarm.icalString.includes("ATTACH:file:///sound.wav"));
+
+  // Adding twice shouldn't change anything
+  alarm.addAttachment(sound);
+  addedAttachments = alarm.getAttachments();
+  equal(addedAttachments.length, 1);
+  equal(addedAttachments[0].wrappedJSObject, sound);
+
+  try {
+    alarm.addAttachment(sound2);
+    do_throw("Adding a second attachment should fail for type AUDIO");
+  } catch (e) {
+    // TODO looks like this test is disabled. Why?
+  }
+
+  // Deleting should work
+  alarm.deleteAttachment(sound);
+  addedAttachments = alarm.getAttachments();
+  equal(addedAttachments.length, 0);
+
+  // As well as clearing
+  alarm.addAttachment(sound);
+  alarm.clearAttachments();
+  addedAttachments = alarm.getAttachments();
+  equal(addedAttachments.length, 0);
+
+  // AUDIO alarms should only be allowing one attachment, and folding any with the same value
+  alarm.icalString = dedent`
+        BEGIN:VALARM
+        ACTION:AUDIO
+        TRIGGER;VALUE=DURATION:-PT5M
+        ATTACH:Basso
+        UID:28F8007B-FE56-442E-917C-1F4E48DD406A
+        X-APPLE-DEFAULT-ALARM:TRUE
+        ATTACH:Basso
+        END:VALARM
+    `;
+  equal(alarm.icalString.match(/ATTACH:Basso/g).length, 1);
+
+  dump("Done\n");
+}
+
+function test_custom_alarm() {
+  dump("Testing X-SMS (custom) alarms...");
+  let alarm = new CalAlarm();
+  // Set ACTION to a custom value, make sure this was not rejected
+  alarm.action = "X-SMS";
+  equal(alarm.action, "X-SMS");
+
+  // There is no restriction on DESCRIPTION for custom alarms
+  alarm.description = "description";
+  equal(alarm.description, "description");
+
+  // There is no restriction on SUMMARY for custom alarms
+  alarm.summary = "summary";
+  equal(alarm.summary, "summary");
+
+  // Test for attendees
+  let attendee1 = new CalAttendee();
+  attendee1.id = "mailto:horst";
+  let attendee2 = new CalAttendee();
+  attendee2.id = "mailto:gustav";
+
+  equal(alarm.getAttendees().length, 0);
+  alarm.addAttendee(attendee1);
+  equal(alarm.getAttendees().length, 1);
+  alarm.addAttendee(attendee2);
+  equal(alarm.getAttendees().length, 2);
+  alarm.addAttendee(attendee1);
+  equal(alarm.getAttendees().length, 2);
+
+  alarm.deleteAttendee(attendee1);
+  equal(alarm.getAttendees().length, 1);
+
+  alarm.clearAttendees();
+  equal(alarm.getAttendees().length, 0);
+
+  // Test for attachments
+  let attach1 = new CalAttachment();
+  attach1.uri = Services.io.newURI("file:///example.txt");
+  let attach2 = new CalAttachment();
+  attach2.uri = Services.io.newURI("file:///example2.txt");
+
+  alarm.addAttachment(attach1);
+  alarm.addAttachment(attach2);
+
+  let addedAttachments = alarm.getAttachments();
+  equal(addedAttachments.length, 2);
+  equal(addedAttachments[0].wrappedJSObject, attach1);
+  equal(addedAttachments[1].wrappedJSObject, attach2);
+
+  alarm.deleteAttachment(attach1);
+  addedAttachments = alarm.getAttachments();
+  equal(addedAttachments.length, 1);
+
+  alarm.clearAttachments();
+  addedAttachments = alarm.getAttachments();
+  equal(addedAttachments.length, 0);
+}
+
+// Check if any combination of REPEAT and DURATION work as expected.
+function test_repeat() {
+  dump("Testing REPEAT and DURATION properties...");
+  let alarm = new CalAlarm();
+
+  // Check initial value
+  equal(alarm.repeat, 0);
+  equal(alarm.repeatOffset, null);
+  equal(alarm.repeatDate, null);
+
+  // Should not be able to get REPEAT when DURATION is not set
+  alarm.repeat = 1;
+  equal(alarm.repeat, 0);
+
+  // Both REPEAT and DURATION should be accessible, when the two are set.
+  alarm.repeatOffset = cal.createDuration();
+  notEqual(alarm.repeatOffset, null);
+  notEqual(alarm.repeat, 0);
+
+  // Should not be able to get DURATION when REPEAT is not set
+  alarm.repeat = null;
+  equal(alarm.repeatOffset, null);
+
+  // Should be able to unset alarm DURATION attribute. (REPEAT already tested above)
+  try {
+    alarm.repeatOffset = null;
+  } catch (e) {
+    do_throw("Could not set repeatOffset attribute to null" + e);
+  }
+
+  // Check unset value
+  equal(alarm.repeat, 0);
+  equal(alarm.repeatOffset, null);
+
+  // Check repeatDate
+  alarm = new CalAlarm();
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_ABSOLUTE;
+  alarm.alarmDate = cal.createDateTime();
+  alarm.repeat = 1;
+  alarm.repeatOffset = cal.createDuration();
+  alarm.repeatOffset.inSeconds = 3600;
+
+  let date = alarm.alarmDate.clone();
+  date.second += 3600;
+  equal(alarm.repeatDate.icalString, date.icalString);
+
+  dump("Done\n");
+}
+
+function test_xprop() {
+  dump("Testing X-Props...");
+  let alarm = new CalAlarm();
+  alarm.setProperty("X-PROP", "X-VALUE");
+  ok(alarm.hasProperty("X-PROP"));
+  equal(alarm.getProperty("X-PROP"), "X-VALUE");
+  alarm.deleteProperty("X-PROP");
+  ok(!alarm.hasProperty("X-PROP"));
+  equal(alarm.getProperty("X-PROP"), null);
+
+  // also check X-MOZ-LASTACK prop
+  let date = cal.createDateTime();
+  alarm.setProperty("X-MOZ-LASTACK", date.icalString);
+  alarm.action = "DISPLAY";
+  alarm.description = "test";
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_START;
+  alarm.offset = cal.createDuration("-PT5M");
+  ok(alarm.icalComponent.serializeToICS().includes(date.icalString));
+
+  alarm.deleteProperty("X-MOZ-LASTACK");
+  ok(!alarm.icalComponent.serializeToICS().includes(date.icalString));
+  dump("Done\n");
+}
+
+function test_dates() {
+  dump("Testing alarm dates...");
+  let passed;
+  // Initial value
+  let alarm = new CalAlarm();
+  equal(alarm.alarmDate, null);
+  equal(alarm.offset, null);
+
+  // Set an offset and check it
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_START;
+  let offset = cal.createDuration("-PT5M");
+  alarm.offset = offset;
+  equal(alarm.alarmDate, null);
+  equal(alarm.offset, offset);
+  try {
+    alarm.alarmDate = cal.createDateTime();
+    passed = false;
+  } catch (e) {
+    passed = true;
+  }
+  if (!passed) {
+    do_throw("Setting alarmDate when alarm is relative should not succeed");
+  }
+
+  // Set an absolute time and check it
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_ABSOLUTE;
+  let alarmDate = createDate(2007, 0, 1, true, 2, 0, 0);
+  alarm.alarmDate = alarmDate;
+  equal(alarm.alarmDate.icalString, alarmDate.icalString);
+  equal(alarm.offset, null);
+  try {
+    alarm.offset = cal.createDuration();
+    passed = false;
+  } catch (e) {
+    passed = true;
+  }
+  if (!passed) {
+    do_throw("Setting offset when alarm is absolute should not succeed");
+  }
+
+  dump("Done\n");
+}
+
+var propMap = {
+  related: Ci.calIAlarm.ALARM_RELATED_START,
+  repeat: 1,
+  action: "X-TEST",
+  description: "description",
+  summary: "summary",
+  offset: cal.createDuration("PT4M"),
+  repeatOffset: cal.createDuration("PT1M"),
+};
+var clonePropMap = {
+  related: Ci.calIAlarm.ALARM_RELATED_END,
+  repeat: 2,
+  action: "X-CHANGED",
+  description: "description-changed",
+  summary: "summary-changed",
+  offset: cal.createDuration("PT5M"),
+  repeatOffset: cal.createDuration("PT2M"),
+};
+
+function test_immutable() {
+  dump("Testing immutable alarms...");
+  let alarm = new CalAlarm();
+  // Set up each attribute
+  for (let prop in propMap) {
+    alarm[prop] = propMap[prop];
+  }
+
+  // Set up some extra props
+  alarm.setProperty("X-FOO", "X-VAL");
+  alarm.setProperty("X-DATEPROP", cal.createDateTime());
+  alarm.addAttendee(new CalAttendee());
+
+  // Initial checks
+  ok(alarm.isMutable);
+  alarm.makeImmutable();
+  ok(!alarm.isMutable);
+  alarm.makeImmutable();
+  ok(!alarm.isMutable);
+
+  // Check each attribute
+  for (let prop in propMap) {
+    try {
+      alarm[prop] = propMap[prop];
+    } catch (e) {
+      equal(e.result, Cr.NS_ERROR_OBJECT_IS_IMMUTABLE);
+      continue;
+    }
+    do_throw("Attribute " + prop + " was writable while item was immutable");
+  }
+
+  // Functions
+  throws(() => {
+    alarm.setProperty("X-FOO", "changed");
+  }, /Can not modify immutable data container/);
+
+  throws(() => {
+    alarm.deleteProperty("X-FOO");
+  }, /Can not modify immutable data container/);
+
+  ok(!alarm.getProperty("X-DATEPROP").isMutable);
+
+  dump("Done\n");
+}
+
+function test_clone() {
+  dump("Testing cloning alarms...");
+  let alarm = new CalAlarm();
+  // Set up each attribute
+  for (let prop in propMap) {
+    alarm[prop] = propMap[prop];
+  }
+
+  // Set up some extra props
+  alarm.setProperty("X-FOO", "X-VAL");
+  alarm.setProperty("X-DATEPROP", cal.createDateTime());
+  alarm.addAttendee(new CalAttendee());
+
+  // Make a copy
+  let newAlarm = alarm.clone();
+  newAlarm.makeImmutable();
+  newAlarm = newAlarm.clone();
+  ok(newAlarm.isMutable);
+
+  // Check if item is still the same
+  // TODO This is not quite optimal, maybe someone can find a better way to do
+  // the comparisons.
+  for (let prop in propMap) {
+    if (prop == "item") {
+      equal(alarm.item.icalString, newAlarm.item.icalString);
+    } else {
+      try {
+        alarm[prop].QueryInterface(Ci.nsISupports);
+        equal(alarm[prop].icalString, newAlarm[prop].icalString);
+      } catch {
+        equal(alarm[prop], newAlarm[prop]);
+      }
+    }
+  }
+
+  // Check if changes on the cloned object do not affect the original object.
+  for (let prop in clonePropMap) {
+    newAlarm[prop] = clonePropMap[prop];
+    dump("Checking " + prop + "...");
+    notEqual(alarm[prop], newAlarm[prop]);
+    dump("OK!\n");
+    break;
+  }
+
+  // Check x props
+  alarm.setProperty("X-FOO", "BAR");
+  equal(alarm.getProperty("X-FOO"), "BAR");
+  let date = alarm.getProperty("X-DATEPROP");
+  equal(date.isMutable, true);
+
+  // Test xprop params
+  alarm.icalString =
+    "BEGIN:VALARM\n" +
+    "ACTION:DISPLAY\n" +
+    "TRIGGER:-PT15M\n" +
+    "X-FOO;X-PARAM=PARAMVAL:BAR\n" +
+    "DESCRIPTION:TEST\n" +
+    "END:VALARM";
+
+  newAlarm = alarm.clone();
+  equal(alarm.icalString, newAlarm.icalString);
+
+  dump("Done\n");
+}
+
+function test_serialize() {
+  // most checks done by other tests, these don't fit into categories
+  let alarm = new CalAlarm();
+
+  throws(
+    () => {
+      alarm.icalComponent = cal.icsService.createIcalComponent("BARF");
+    },
+    /0x80070057/,
+    "Invalid Argument"
+  );
+
+  function addProp(name, value) {
+    let prop = cal.icsService.createIcalProperty(name);
+    prop.value = value;
+    comp.addProperty(prop);
+  }
+  function addActionDisplay() {
+    addProp("ACTION", "DISPLAY");
+  }
+  function addActionEmail() {
+    addProp("ACTION", "EMAIL");
+  }
+  function addTrigger() {
+    addProp("TRIGGER", "-PT15M");
+  }
+  function addDescr() {
+    addProp("DESCRIPTION", "TEST");
+  }
+  function addDuration() {
+    addProp("DURATION", "-PT15M");
+  }
+  function addRepeat() {
+    addProp("REPEAT", "1");
+  }
+  function addAttendee() {
+    addProp("ATTENDEE", "mailto:horst");
+  }
+  function addAttachment() {
+    addProp("ATTACH", "data:yeah");
+  }
+
+  // All is there, should not throw
+  let comp = cal.icsService.createIcalComponent("VALARM");
+  addActionDisplay();
+  addTrigger();
+  addDescr();
+  addDuration();
+  addRepeat();
+  alarm.icalComponent = comp;
+  alarm.toString();
+
+  // Attachments and attendees
+  comp = cal.icsService.createIcalComponent("VALARM");
+  addActionEmail();
+  addTrigger();
+  addDescr();
+  addAttendee();
+  addAttachment();
+  alarm.icalComponent = comp;
+  alarm.toString();
+
+  // Missing action
+  throws(
+    () => {
+      comp = cal.icsService.createIcalComponent("VALARM");
+      addTrigger();
+      addDescr();
+      alarm.icalComponent = comp;
+    },
+    /Illegal value/,
+    "Invalid Argument"
+  );
+
+  // Missing trigger
+  throws(
+    () => {
+      comp = cal.icsService.createIcalComponent("VALARM");
+      addActionDisplay();
+      addDescr();
+      alarm.icalComponent = comp;
+    },
+    /Illegal value/,
+    "Invalid Argument"
+  );
+
+  // Missing duration with repeat
+  throws(
+    () => {
+      comp = cal.icsService.createIcalComponent("VALARM");
+      addActionDisplay();
+      addTrigger();
+      addDescr();
+      addRepeat();
+      alarm.icalComponent = comp;
+    },
+    /Illegal value/,
+    "Invalid Argument"
+  );
+
+  // Missing repeat with duration
+  throws(
+    () => {
+      comp = cal.icsService.createIcalComponent("VALARM");
+      addActionDisplay();
+      addTrigger();
+      addDescr();
+      addDuration();
+      alarm.icalComponent = comp;
+    },
+    /Illegal value/,
+    "Invalid Argument"
+  );
+}
+
+function test_strings() {
+  // Serializing the string shouldn't throw, but we don't really care about
+  // the string itself.
+  let alarm = new CalAlarm();
+  alarm.action = "DISPLAY";
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_ABSOLUTE;
+  alarm.alarmDate = cal.createDateTime();
+  alarm.toString();
+
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_START;
+  alarm.offset = cal.createDuration();
+  alarm.toString();
+  alarm.toString(new CalTodo());
+
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_END;
+  alarm.offset = cal.createDuration();
+  alarm.toString();
+  alarm.toString(new CalTodo());
+
+  alarm.offset = cal.createDuration("P1D");
+  alarm.toString();
+
+  alarm.offset = cal.createDuration("PT1H");
+  alarm.toString();
+
+  alarm.offset = cal.createDuration("-PT1H");
+  alarm.toString();
+}
diff --git a/comm/calendar/test/unit/test_alarmservice.js b/comm/calendar/test/unit/test_alarmservice.js
new file mode 100644
index 0000000000..df61dc029b
--- /dev/null
+++ b/comm/calendar/test/unit/test_alarmservice.js
@@ -0,0 +1,606 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+var { TestUtils } = ChromeUtils.importESModule("resource://testing-common/TestUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAlarm: "resource:///modules/CalAlarm.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalRecurrenceInfo: "resource:///modules/CalRecurrenceInfo.jsm",
+});
+
+var EXPECT_NONE = 0;
+var EXPECT_FIRED = 1;
+var EXPECT_TIMER = 2;
+
+function do_check_xor(a, b, aMessage) {
+  return ok((a && !b) || (!a && b), aMessage);
+}
+
+var alarmObserver = {
+  QueryInterface: ChromeUtils.generateQI(["calIAlarmServiceObserver"]),
+
+  service: null,
+  firedMap: {},
+  expectedMap: {},
+  pendingOps: {},
+
+  onAlarm(aItem, aAlarm) {
+    this.firedMap[aItem.hashId] = this.firedMap[aItem.hashId] || {};
+    this.firedMap[aItem.hashId][aAlarm.icalString] = true;
+  },
+
+  onNotification(item) {},
+
+  onRemoveAlarmsByItem(aItem) {
+    if (aItem.hashId in this.firedMap) {
+      delete this.firedMap[aItem.hashId];
+    }
+  },
+
+  onRemoveAlarmsByCalendar() {},
+
+  onAlarmsLoaded(aCalendar) {
+    this.checkLoadStatus();
+    if (aCalendar.id in this.pendingOps) {
+      this.pendingOps[aCalendar.id].call();
+    }
+  },
+
+  async doOnAlarmsLoaded(aCalendar) {
+    this.checkLoadStatus();
+    if (
+      aCalendar.id in this.service.mLoadedCalendars &&
+      this.service.mLoadedCalendars[aCalendar.id]
+    ) {
+      // the calendar's alarms have already been loaded
+    } else {
+      await new Promise(resolve => {
+        // the calendar hasn't been fully loaded yet, set as a pending operation
+        this.pendingOps[aCalendar.id] = resolve;
+      });
+    }
+  },
+
+  getTimer(aCalendarId, aItemId, aAlarmStr) {
+    return aCalendarId in this.service.mTimerMap &&
+      aItemId in this.service.mTimerMap[aCalendarId] &&
+      aAlarmStr in this.service.mTimerMap[aCalendarId][aItemId]
+      ? this.service.mTimerMap[aCalendarId][aItemId][aAlarmStr]
+      : null;
+  },
+
+  expectResult(aCalendar, aItem, aAlarm, aExpected) {
+    let expectedAndTitle = {
+      expected: aExpected,
+      title: aItem.title,
+    };
+    this.expectedMap[aCalendar.id] = this.expectedMap[aCalendar.id] || {};
+    this.expectedMap[aCalendar.id][aItem.hashId] =
+      this.expectedMap[aCalendar.id][aItem.hashId] || {};
+    this.expectedMap[aCalendar.id][aItem.hashId][aAlarm.icalString] = expectedAndTitle;
+  },
+
+  expectOccurrences(aCalendar, aItem, aAlarm, aExpectedArray) {
+    // we need to be earlier than the first occurrence
+    let date = aItem.startDate.clone();
+    date.second -= 1;
+
+    for (let expected of aExpectedArray) {
+      let occ = aItem.recurrenceInfo.getNextOccurrence(date);
+      occ.QueryInterface(Ci.calIEvent);
+      date = occ.startDate;
+      this.expectResult(aCalendar, occ, aAlarm, expected);
+    }
+  },
+
+  checkExpected(aMessage) {
+    for (let calId in this.expectedMap) {
+      for (let id in this.expectedMap[calId]) {
+        for (let icalString in this.expectedMap[calId][id]) {
+          let expectedAndTitle = this.expectedMap[calId][id][icalString];
+          // if no explicit message has been passed, take the item title
+          let message = typeof aMessage == "string" ? aMessage : expectedAndTitle.title;
+          // only alarms expected as fired should exist in our fired alarm map
+          do_check_xor(
+            expectedAndTitle.expected != EXPECT_FIRED,
+            id in this.firedMap && icalString in this.firedMap[id],
+            message + "; check fired"
+          );
+          // only alarms expected as timers should exist in the service's timer map
+          do_check_xor(
+            expectedAndTitle.expected != EXPECT_TIMER,
+            !!this.getTimer(calId, id, icalString),
+            message + "; check timer"
+          );
+        }
+      }
+    }
+  },
+
+  checkLoadStatus() {
+    for (let calId in this.service.mLoadedCalendars) {
+      if (!this.service.mLoadedCalendars[calId]) {
+        // at least one calendar hasn't finished loading alarms
+        ok(this.service.isLoading);
+        return;
+      }
+    }
+    ok(!this.service.isLoading);
+  },
+
+  clear() {
+    this.firedMap = {};
+    this.pendingOps = {};
+    this.expectedMap = {};
+  },
+};
+
+add_setup(async function () {
+  do_get_profile();
+  await new Promise(resolve =>
+    do_calendar_startup(() => {
+      alarmObserver.service = Cc["@mozilla.org/calendar/alarm-service;1"].getService(
+        Ci.calIAlarmService
+      ).wrappedJSObject;
+      ok(!alarmObserver.service.mStarted);
+      alarmObserver.service.startup(null);
+      ok(alarmObserver.service.mStarted);
+
+      // we need to replace the existing observers with our observer
+      for (let obs of alarmObserver.service.mObservers.values()) {
+        alarmObserver.service.removeObserver(obs);
+      }
+      alarmObserver.service.addObserver(alarmObserver);
+      resolve();
+    })
+  );
+});
+
+function createAlarmFromDuration(aOffset) {
+  let alarm = new CalAlarm();
+
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_START;
+  alarm.offset = cal.createDuration(aOffset);
+
+  return alarm;
+}
+
+function createEventWithAlarm(aCalendar, aStart, aEnd, aOffset, aRRule) {
+  let alarm = null;
+  let item = new CalEvent();
+
+  item.id = cal.getUUID();
+  item.calendar = aCalendar;
+  item.startDate = aStart || cal.dtz.now();
+  item.endDate = aEnd || cal.dtz.now();
+  if (aOffset) {
+    alarm = createAlarmFromDuration(aOffset);
+    item.addAlarm(alarm);
+  }
+  if (aRRule) {
+    item.recurrenceInfo = new CalRecurrenceInfo(item);
+    item.recurrenceInfo.appendRecurrenceItem(cal.createRecurrenceRule(aRRule));
+  }
+  return [item, alarm];
+}
+
+async function addTestItems(aCalendar) {
+  let item, alarm;
+
+  // alarm on an item starting more than a month in the past should not fire
+  let date = cal.dtz.now();
+  date.day -= 32;
+  [item, alarm] = createEventWithAlarm(aCalendar, date, date, "P7D");
+  item.title = "addTestItems Test 1";
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_NONE);
+  await aCalendar.addItem(item);
+
+  // alarm 15 minutes ago should fire
+  date = cal.dtz.now();
+  [item, alarm] = createEventWithAlarm(aCalendar, date, date, "-PT15M");
+  item.title = "addTestItems Test 2";
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_FIRED);
+  await aCalendar.addItem(item);
+
+  // alarm within 6 hours should have a timer set
+  [item, alarm] = createEventWithAlarm(aCalendar, date, date, "PT1H");
+  item.title = "addTestItems Test 3";
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_TIMER);
+  await aCalendar.addItem(item);
+
+  // alarm more than 6 hours in the future should not have a timer set
+  [item, alarm] = createEventWithAlarm(aCalendar, date, date, "PT7H");
+  item.title = "addTestItems Test 4";
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_NONE);
+  await aCalendar.addItem(item);
+
+  // test multiple alarms on an item
+  [item, alarm] = createEventWithAlarm(aCalendar, date, date);
+  item.title = "addTestItems Test 5";
+  const firedOffsets = [
+    ["-PT1H", EXPECT_FIRED],
+    ["-PT15M", EXPECT_FIRED],
+    ["PT1H", EXPECT_TIMER],
+    ["PT7H", EXPECT_NONE],
+    ["P7D", EXPECT_NONE],
+  ];
+
+  firedOffsets.forEach(([offset, expected]) => {
+    alarm = createAlarmFromDuration(offset);
+    item.addAlarm(alarm);
+    alarmObserver.expectResult(aCalendar, item, alarm, expected);
+  });
+  await aCalendar.addItem(item);
+
+  // Bug 1344068 - Alarm with lastAck on exception, should take parent lastAck.
+  // Alarm 15 minutes ago should fire.
+  date = cal.dtz.now();
+  [item, alarm] = createEventWithAlarm(aCalendar, date, date, "-PT15M", "RRULE:FREQ=DAILY;COUNT=1");
+  item.title = "addTestItems Test 6";
+
+  // Parent item is acknowledged before alarm, so it should fire.
+  let lastAck = item.startDate.clone();
+  lastAck.hour -= 1;
+  item.alarmLastAck = lastAck;
+
+  // Occurrence is acknowledged after alarm (start date), so if the alarm
+  // service wrongly uses the exception occurrence then we catch it.
+  let occ = item.recurrenceInfo.getOccurrenceFor(item.startDate);
+  occ.alarmLastAck = item.startDate.clone();
+  item.recurrenceInfo.modifyException(occ, true);
+
+  alarmObserver.expectOccurrences(aCalendar, item, alarm, [EXPECT_FIRED]);
+  await aCalendar.addItem(item);
+
+  // daily repeating event starting almost 2 full days ago. The alarms on the first 2 occurrences
+  // should fire, and a timer should be set for the next occurrence only
+  date = cal.dtz.now();
+  date.hour -= 47;
+  [item, alarm] = createEventWithAlarm(aCalendar, date, date, "-PT15M", "RRULE:FREQ=DAILY");
+  item.title = "addTestItems Test 7";
+  alarmObserver.expectOccurrences(aCalendar, item, alarm, [
+    EXPECT_FIRED,
+    EXPECT_FIRED,
+    EXPECT_TIMER,
+    EXPECT_NONE,
+    EXPECT_NONE,
+  ]);
+  await aCalendar.addItem(item);
+
+  // monthly repeating event starting 2 months and a day ago. The alarms on the first 2 occurrences
+  // should be ignored, the alarm on the next occurrence only should fire.
+  // Missing recurrences of the event in particular days of the year generate exceptions to the
+  // regular sequence of alarms.
+  date = cal.dtz.now();
+  let statusAlarmSequences = {
+    reg: [EXPECT_NONE, EXPECT_NONE, EXPECT_FIRED, EXPECT_NONE, EXPECT_NONE],
+    excep1: [EXPECT_NONE, EXPECT_FIRED, EXPECT_NONE, EXPECT_NONE, EXPECT_NONE],
+    excep2: [EXPECT_NONE, EXPECT_NONE, EXPECT_NONE, EXPECT_NONE, EXPECT_NONE],
+  };
+  let expected = [];
+  if (date.day == 1) {
+    // Exceptions for missing occurrences on months with 30 days when the event starts on 31st.
+    let sequence = [
+      "excep1",
+      "reg",
+      "excep2",
+      "excep1",
+      "reg",
+      "excep1",
+      "reg",
+      "excep1",
+      "reg",
+      "excep2",
+      "excep1",
+      "reg",
+    ][date.month];
+    expected = statusAlarmSequences[sequence];
+  } else if (date.day == 30 && (date.month == 2 || date.month == 3)) {
+    // Exceptions for missing occurrences or different start date caused by February.
+    let leapYear = date.endOfYear.yearday == 366;
+    expected = leapYear ? statusAlarmSequences.reg : statusAlarmSequences.excep1;
+  } else if (date.day == 31 && date.month == 2) {
+    // Exceptions for missing occurrences caused by February.
+    expected = statusAlarmSequences.excep1;
+  } else {
+    // Regular sequence of alarms expected for all the others days.
+    expected = statusAlarmSequences.reg;
+  }
+  date.month -= 2;
+  date.day -= 1;
+  [item, alarm] = createEventWithAlarm(aCalendar, date, date, "-PT15M", "RRULE:FREQ=MONTHLY");
+  item.title = "addTestItems Test 8";
+  alarmObserver.expectOccurrences(aCalendar, item, alarm, expected);
+  await aCalendar.addItem(item);
+}
+
+async function doModifyItemTest(aCalendar) {
+  let item, alarm;
+
+  // begin with item starting before the alarm date range
+  let date = cal.dtz.now();
+  date.day -= 32;
+  [item, alarm] = createEventWithAlarm(aCalendar, date, date, "PT0S");
+  await aCalendar.addItem(item);
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_NONE);
+  alarmObserver.checkExpected("doModifyItemTest Test 1");
+
+  // move event into the fired range
+  let oldItem = item.clone();
+  date.day += 31;
+  item.startDate = date.clone();
+  item.generation++;
+  await aCalendar.modifyItem(item, oldItem);
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_FIRED);
+  alarmObserver.checkExpected("doModifyItemTest Test 2");
+
+  // move event into the timer range
+  oldItem = item.clone();
+  date.hour += 25;
+  item.startDate = date.clone();
+  item.generation++;
+  await aCalendar.modifyItem(item, oldItem);
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_TIMER);
+  alarmObserver.checkExpected("doModifyItemTest Test 3");
+
+  // move event past the timer range
+  oldItem = item.clone();
+  date.hour += 6;
+  item.startDate = date.clone();
+  item.generation++;
+  await aCalendar.modifyItem(item, oldItem);
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_NONE);
+  alarmObserver.checkExpected("doModifyItemTest Test 4");
+
+  // re-move the event in the timer range and verify that the timer
+  // doesn't change when the timezone changes to floating (bug 1300493).
+  oldItem = item.clone();
+  date.hour -= 6;
+  item.startDate = date.clone();
+  item.generation++;
+  await aCalendar.modifyItem(item, oldItem);
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_TIMER);
+  alarmObserver.checkExpected("doModifyItemTest Test 5");
+  let oldTimer = alarmObserver.getTimer(aCalendar.id, item.hashId, alarm.icalString);
+  oldItem = item.clone();
+  // change the timezone to floating
+  item.startDate.timezone = cal.dtz.floating;
+  item.generation++;
+  await aCalendar.modifyItem(item, oldItem);
+  // the alarm must still be timer and with the same value (apart from milliseconds)
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_TIMER);
+  alarmObserver.checkExpected("doModifyItemTest Test 5, floating timezone");
+  let newTimer = alarmObserver.getTimer(aCalendar.id, item.hashId, alarm.icalString);
+  ok(
+    newTimer.delay - oldTimer.delay <= 1000,
+    "doModifyItemTest Test 5, floating timezone; check timer value"
+  );
+}
+
+async function doDeleteItemTest(aCalendar) {
+  alarmObserver.clear();
+  let item, alarm;
+  let item2, alarm2;
+
+  // create a fired alarm and a timer
+  let date = cal.dtz.now();
+  [item, alarm] = createEventWithAlarm(aCalendar, date, date, "-PT5M");
+  [item2, alarm2] = createEventWithAlarm(aCalendar, date, date, "PT1H");
+  item.title = "doDeleteItemTest item Test 1";
+  item2.title = "doDeleteItemTest item2 Test 1";
+  await aCalendar.addItem(item);
+  await aCalendar.addItem(item2);
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_FIRED);
+  alarmObserver.expectResult(aCalendar, item2, alarm2, EXPECT_TIMER);
+  alarmObserver.checkExpected();
+
+  // item deletion should clear the fired alarm and timer
+  await aCalendar.deleteItem(item);
+  await aCalendar.deleteItem(item2);
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_NONE);
+  alarmObserver.expectResult(aCalendar, item2, alarm2, EXPECT_NONE);
+  alarmObserver.checkExpected("doDeleteItemTest, cleared fired alarm and timer");
+}
+
+async function doAcknowledgeTest(aCalendar) {
+  alarmObserver.clear();
+  let item, alarm;
+  let item2, alarm2;
+
+  // create the fired alarms
+  let date = cal.dtz.now();
+  [item, alarm] = createEventWithAlarm(aCalendar, date, date, "-PT5M");
+  [item2, alarm2] = createEventWithAlarm(aCalendar, date, date, "-PT5M");
+  item.title = "doAcknowledgeTest item Test 1";
+  item2.title = "doAcknowledgeTest item2 Test 1";
+  await aCalendar.addItem(item);
+  await aCalendar.addItem(item2);
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_FIRED);
+  alarmObserver.expectResult(aCalendar, item2, alarm2, EXPECT_FIRED);
+  alarmObserver.checkExpected();
+
+  // test snooze alarm
+  alarmObserver.service.snoozeAlarm(item, alarm, cal.createDuration("PT1H"));
+  alarmObserver.expectResult(aCalendar, item, alarm, EXPECT_TIMER);
+  alarmObserver.checkExpected("doAcknowledgeTest, test snooze alarm");
+
+  // the snoozed alarm timer delay should be close to an hour
+  let tmr = alarmObserver.getTimer(aCalendar.id, item.hashId, alarm.icalString);
+  ok(
+    Math.abs(tmr.delay - 3600000) <= 1000,
+    "doAcknowledgeTest, snoozed alarm timer delay close to an hour"
+  );
+
+  // test dismiss alarm
+  alarmObserver.service.dismissAlarm(item2, alarm2);
+  alarmObserver.expectResult(aCalendar, item2, alarm2, EXPECT_NONE);
+  alarmObserver.checkExpected("doAcknowledgeTest, test dismiss alarm");
+}
+
+async function doRunTest(aOnCalendarCreated) {
+  alarmObserver.clear();
+
+  let memory = cal.manager.createCalendar("memory", Services.io.newURI("moz-memory-calendar://"));
+  memory.id = cal.getUUID();
+
+  if (aOnCalendarCreated) {
+    await aOnCalendarCreated(memory);
+  }
+
+  cal.manager.registerCalendar(memory);
+  await alarmObserver.doOnAlarmsLoaded(memory);
+  return memory;
+}
+
+/**
+ * Test the initial alarm loading of a calendar with existing data.
+ */
+add_task(async function test_loadCalendar() {
+  await doRunTest(async memory => addTestItems(memory));
+  alarmObserver.checkExpected();
+});
+
+/**
+ * Test adding alarm data to a calendar already registered.
+ */
+add_task(async function test_addItems() {
+  let memory = await doRunTest();
+  await addTestItems(memory);
+  alarmObserver.checkExpected();
+});
+
+/**
+ * Test response to modification of alarm data.
+ */
+add_task(async function test_modifyItems() {
+  let memory = await doRunTest();
+  await doModifyItemTest(memory);
+  await doDeleteItemTest(memory);
+  await doAcknowledgeTest(memory);
+});
+
+/**
+ * Test an array of timers has expected delay values.
+ *
+ * @param {nsITimer[]} timers - An array of nsITimer.
+ * @param {number[]} expected - Expected delays in seconds.
+ */
+function matchTimers(timers, expected) {
+  let delays = timers.map(timer => timer.delay / 1000);
+  let matched = true;
+  for (let i = 0; i < delays.length; i++) {
+    if (Math.abs(delays[i] - expected[i]) > 2) {
+      matched = false;
+
+      break;
+    }
+  }
+  ok(matched, `Delays=${delays} should match Expected=${expected}`);
+}
+
+/**
+ * Test notification timers are set up correctly when add/modify/remove a
+ * calendar item.
+ */
+add_task(async function test_notificationTimers() {
+  let memory = await doRunTest();
+  // Add an item.
+  let date = cal.dtz.now();
+  date.hour += 1;
+  let item, oldItem;
+  [item] = createEventWithAlarm(memory, date, date, null);
+  await memory.addItem(item);
+  equal(
+    alarmObserver.service.mNotificationTimerMap[item.calendar.id],
+    undefined,
+    "should have no notification timer"
+  );
+
+  // Set the pref to have one notifiaction.
+  Services.prefs.setCharPref("calendar.notifications.times", "-PT1H");
+  oldItem = item.clone();
+  date.hour += 1;
+  item.startDate = date.clone();
+  item.generation++;
+  await memory.modifyItem(item, oldItem);
+  // Should have one notification timer
+  matchTimers(alarmObserver.service.mNotificationTimerMap[item.calendar.id][item.hashId], [3600]);
+
+  // Set the pref to have three notifiactions.
+  Services.prefs.setCharPref("calendar.notifications.times", "END:PT2M,PT0M,END:-PT30M,-PT5M");
+  oldItem = item.clone();
+  date.hour -= 1;
+  item.startDate = date.clone();
+  date.hour += 1;
+  item.endDate = date.clone();
+  item.generation++;
+  await memory.modifyItem(item, oldItem);
+  // Should have four notification timers.
+  matchTimers(alarmObserver.service.mNotificationTimerMap[item.calendar.id][item.hashId], [
+    3300, // 55 minutes
+    3600, // 60 minutes
+    5400, // 90 minutes, which is 30 minutes before the end (END:-PT30M)
+    7320, // 122 minutes, which is 2 minutes after the end (END:PT2M)
+  ]);
+
+  alarmObserver.service.removeFiredNotificationTimer(item);
+  // Should have three notification timers.
+  matchTimers(
+    alarmObserver.service.mNotificationTimerMap[item.calendar.id][item.hashId],
+    [3600, 5400, 7320]
+  );
+
+  await memory.deleteItem(item);
+  equal(
+    alarmObserver.service.mNotificationTimerMap[item.calendar.id],
+    undefined,
+    "notification timers should be removed"
+  );
+
+  Services.prefs.clearUserPref("calendar.notifications.times");
+});
+
+/**
+ * Test notification timers are set up correctly according to the calendar level
+ * notifications.times config.
+ */
+add_task(async function test_calendarLevelNotificationTimers() {
+  let loaded = false;
+  let item;
+  let memory = await doRunTest();
+
+  if (!loaded) {
+    loaded = true;
+    // Set the global pref to have one notifiaction.
+    Services.prefs.setCharPref("calendar.notifications.times", "-PT1H");
+
+    // Add an item.
+    let date = cal.dtz.now();
+    date.hour += 2;
+    [item] = createEventWithAlarm(memory, date, date, null);
+    await memory.addItem(item);
+
+    // Should have one notification timer.
+    matchTimers(alarmObserver.service.mNotificationTimerMap[item.calendar.id][item.hashId], [3600]);
+    // Set the calendar level pref to have two notification timers.
+    memory.setProperty("notifications.times", "-PT5M,PT0M");
+  }
+
+  await TestUtils.waitForCondition(
+    () => alarmObserver.service.mNotificationTimerMap[item.calendar.id]?.[item.hashId].length == 2
+  );
+  // Should have two notification timers
+  matchTimers(alarmObserver.service.mNotificationTimerMap[item.calendar.id][item.hashId], [
+    6900, // 105 minutes
+    7200, // 120 minutes
+  ]);
+
+  Services.prefs.clearUserPref("calendar.notifications.times");
+});
+
+registerCleanupFunction(() => {
+  Services.prefs.clearUserPref("calendar.notifications.times");
+});
diff --git a/comm/calendar/test/unit/test_alarmutils.js b/comm/calendar/test/unit/test_alarmutils.js
new file mode 100644
index 0000000000..e51453367d
--- /dev/null
+++ b/comm/calendar/test/unit/test_alarmutils.js
@@ -0,0 +1,171 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAlarm: "resource:///modules/CalAlarm.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalTodo: "resource:///modules/CalTodo.jsm",
+});
+
+function run_test() {
+  do_calendar_startup(run_next_test);
+}
+
+add_task(async function test_setDefaultValues_events() {
+  let item, alarm;
+
+  Services.prefs.setIntPref("calendar.alarms.onforevents", 1);
+  Services.prefs.setStringPref("calendar.alarms.eventalarmunit", "hours");
+  Services.prefs.setIntPref("calendar.alarms.eventalarmlen", 60);
+  item = new CalEvent();
+  cal.alarms.setDefaultValues(item);
+  alarm = item.getAlarms()[0];
+  ok(alarm);
+  equal(alarm.related, Ci.calIAlarm.ALARM_RELATED_START);
+  equal(alarm.action, "DISPLAY");
+  equal(alarm.offset.icalString, "-P2DT12H");
+
+  Services.prefs.setIntPref("calendar.alarms.onforevents", 1);
+  Services.prefs.setStringPref("calendar.alarms.eventalarmunit", "yards");
+  Services.prefs.setIntPref("calendar.alarms.eventalarmlen", 20);
+  item = new CalEvent();
+  cal.alarms.setDefaultValues(item);
+  alarm = item.getAlarms()[0];
+  ok(alarm);
+  equal(alarm.related, Ci.calIAlarm.ALARM_RELATED_START);
+  equal(alarm.action, "DISPLAY");
+  equal(alarm.offset.icalString, "-PT20M");
+
+  Services.prefs.setIntPref("calendar.alarms.onforevents", 0);
+  item = new CalEvent();
+  cal.alarms.setDefaultValues(item);
+  equal(item.getAlarms().length, 0);
+
+  let mockCalendar = {
+    getProperty() {
+      return ["SHOUT"];
+    },
+  };
+
+  Services.prefs.setIntPref("calendar.alarms.onforevents", 1);
+  Services.prefs.setStringPref("calendar.alarms.eventalarmunit", "hours");
+  Services.prefs.setIntPref("calendar.alarms.eventalarmlen", 60);
+  item = new CalEvent();
+  item.calendar = mockCalendar;
+  cal.alarms.setDefaultValues(item);
+  alarm = item.getAlarms()[0];
+  ok(alarm);
+  equal(alarm.related, Ci.calIAlarm.ALARM_RELATED_START);
+  equal(alarm.action, "SHOUT");
+  equal(alarm.offset.icalString, "-P2DT12H");
+
+  Services.prefs.clearUserPref("calendar.alarms.onforevents");
+  Services.prefs.clearUserPref("calendar.alarms.eventalarmunit");
+  Services.prefs.clearUserPref("calendar.alarms.eventalarmlen");
+});
+
+add_task(async function test_setDefaultValues_tasks() {
+  let item, alarm;
+  let calnow = cal.dtz.now;
+  let nowDate = cal.createDateTime("20150815T120000");
+  cal.dtz.now = function () {
+    return nowDate;
+  };
+
+  Services.prefs.setIntPref("calendar.alarms.onfortodos", 1);
+  Services.prefs.setStringPref("calendar.alarms.todoalarmunit", "hours");
+  Services.prefs.setIntPref("calendar.alarms.todoalarmlen", 60);
+  item = new CalTodo();
+  equal(item.entryDate, null);
+  cal.alarms.setDefaultValues(item);
+  alarm = item.getAlarms()[0];
+  ok(alarm);
+  equal(alarm.related, Ci.calIAlarm.ALARM_RELATED_START);
+  equal(alarm.action, "DISPLAY");
+  equal(alarm.offset.icalString, "-P2DT12H");
+  equal(item.entryDate.icalString, nowDate.icalString);
+
+  Services.prefs.setIntPref("calendar.alarms.onfortodos", 1);
+  Services.prefs.setStringPref("calendar.alarms.todoalarmunit", "yards");
+  Services.prefs.setIntPref("calendar.alarms.todoalarmlen", 20);
+  item = new CalTodo();
+  cal.alarms.setDefaultValues(item);
+  alarm = item.getAlarms()[0];
+  ok(alarm);
+  equal(alarm.related, Ci.calIAlarm.ALARM_RELATED_START);
+  equal(alarm.action, "DISPLAY");
+  equal(alarm.offset.icalString, "-PT20M");
+
+  Services.prefs.setIntPref("calendar.alarms.onfortodos", 0);
+  item = new CalTodo();
+  cal.alarms.setDefaultValues(item);
+  equal(item.getAlarms().length, 0);
+
+  let mockCalendar = {
+    getProperty() {
+      return ["SHOUT"];
+    },
+  };
+
+  Services.prefs.setIntPref("calendar.alarms.onfortodos", 1);
+  Services.prefs.setStringPref("calendar.alarms.todoalarmunit", "hours");
+  Services.prefs.setIntPref("calendar.alarms.todoalarmlen", 60);
+  item = new CalTodo();
+  item.calendar = mockCalendar;
+  cal.alarms.setDefaultValues(item);
+  alarm = item.getAlarms()[0];
+  ok(alarm);
+  equal(alarm.related, Ci.calIAlarm.ALARM_RELATED_START);
+  equal(alarm.action, "SHOUT");
+  equal(alarm.offset.icalString, "-P2DT12H");
+
+  Services.prefs.clearUserPref("calendar.alarms.onfortodos");
+  Services.prefs.clearUserPref("calendar.alarms.todoalarmunit");
+  Services.prefs.clearUserPref("calendar.alarms.todoalarmlen");
+  cal.dtz.now = calnow;
+});
+
+add_task(async function test_calculateAlarmDate() {
+  let item = new CalEvent();
+  item.startDate = cal.createDateTime("20150815T120000");
+  item.endDate = cal.createDateTime("20150815T130000");
+
+  let calculateAlarmDate = cal.alarms.calculateAlarmDate.bind(cal.alarms, item);
+
+  let alarm = new CalAlarm();
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_ABSOLUTE;
+  alarm.alarmDate = cal.createDateTime("20150815T110000");
+  equal(calculateAlarmDate(alarm).icalString, "20150815T110000");
+
+  alarm = new CalAlarm();
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_START;
+  alarm.offset = cal.createDuration("-PT1H");
+  equal(calculateAlarmDate(alarm).icalString, "20150815T110000Z");
+
+  alarm = new CalAlarm();
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_END;
+  alarm.offset = cal.createDuration("-PT2H");
+  equal(calculateAlarmDate(alarm).icalString, "20150815T110000Z");
+
+  item.startDate.isDate = true;
+  alarm = new CalAlarm();
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_START;
+  alarm.offset = cal.createDuration("-PT1H");
+  equal(calculateAlarmDate(alarm).icalString, "20150814T230000Z");
+  item.startDate.isDate = false;
+
+  item.endDate.isDate = true;
+  alarm = new CalAlarm();
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_END;
+  alarm.offset = cal.createDuration("-PT2H");
+  equal(calculateAlarmDate(alarm).icalString, "20150814T220000Z");
+  item.endDate.isDate = false;
+
+  alarm = new CalAlarm();
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_END;
+  equal(calculateAlarmDate(alarm), null);
+});
diff --git a/comm/calendar/test/unit/test_attachment.js b/comm/calendar/test/unit/test_attachment.js
new file mode 100644
index 0000000000..6e2b935851
--- /dev/null
+++ b/comm/calendar/test/unit/test_attachment.js
@@ -0,0 +1,112 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAttachment: "resource:///modules/CalAttachment.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+function run_test() {
+  test_serialize();
+  test_hashes();
+  test_uriattach();
+  test_binaryattach();
+}
+
+function test_hashes() {
+  let attach = new CalAttachment();
+
+  attach.rawData = "hello";
+  let hash1 = attach.hashId;
+
+  attach.rawData = "world";
+  notEqual(hash1, attach.hashId);
+
+  attach.rawData = "hello";
+  equal(hash1, attach.hashId);
+
+  // Setting raw data should give us a BINARY attachment
+  equal(attach.getParameter("VALUE"), "BINARY");
+
+  attach.uri = Services.io.newURI("http://hello");
+
+  // Setting an uri should delete the value parameter
+  equal(attach.getParameter("VALUE"), null);
+}
+
+function test_uriattach() {
+  let attach = new CalAttachment();
+
+  // Attempt to set a property and check its values
+  let e = new CalEvent();
+  // eslint-disable-next-line no-useless-concat
+  e.icalString = "BEGIN:VEVENT\r\n" + "ATTACH;FMTTYPE=x-moz/test:http://hello\r\n" + "END:VEVENT";
+  let prop = e.icalComponent.getFirstProperty("ATTACH");
+  attach.icalProperty = prop;
+
+  notEqual(attach.getParameter("VALUE"), "BINARY");
+  equal(attach.formatType, "x-moz/test");
+  equal(attach.getParameter("FMTTYPE"), "x-moz/test");
+  equal(attach.uri.spec, Services.io.newURI("http://hello").spec);
+  equal(attach.rawData, "http://hello");
+}
+
+function test_binaryattach() {
+  let attach = new CalAttachment();
+  let e = new CalEvent();
+
+  let attachString =
+    "ATTACH;ENCODING=BASE64;FMTTYPE=x-moz/test2;VALUE=BINARY:aHR0cDovL2hlbGxvMg==\r\n";
+  let icalString = "BEGIN:VEVENT\r\n" + attachString + "END:VEVENT";
+  e.icalString = icalString;
+  let prop = e.icalComponent.getFirstProperty("ATTACH");
+  attach.icalProperty = prop;
+
+  equal(attach.formatType, "x-moz/test2");
+  equal(attach.getParameter("FMTTYPE"), "x-moz/test2");
+  equal(attach.encoding, "BASE64");
+  equal(attach.getParameter("ENCODING"), "BASE64");
+  equal(attach.uri, null);
+  equal(attach.rawData, "aHR0cDovL2hlbGxvMg==");
+  equal(attach.getParameter("VALUE"), "BINARY");
+
+  let propIcalString = attach.icalProperty.icalString;
+  ok(!!propIcalString.match(/ENCODING=BASE64/));
+  ok(!!propIcalString.match(/FMTTYPE=x-moz\/test2/));
+  ok(!!propIcalString.match(/VALUE=BINARY/));
+  ok(!!propIcalString.replace("\r\n ", "").match(/:aHR0cDovL2hlbGxvMg==/));
+
+  propIcalString = attach.clone().icalProperty.icalString;
+
+  ok(!!propIcalString.match(/ENCODING=BASE64/));
+  ok(!!propIcalString.match(/FMTTYPE=x-moz\/test2/));
+  ok(!!propIcalString.match(/VALUE=BINARY/));
+  ok(!!propIcalString.replace("\r\n ", "").match(/:aHR0cDovL2hlbGxvMg==/));
+}
+
+function test_serialize() {
+  let attach = new CalAttachment();
+  attach.formatType = "x-moz/test2";
+  attach.uri = Services.io.newURI("data:text/plain,");
+  equal(attach.icalString, "ATTACH;FMTTYPE=x-moz/test2:data:text/plain,\r\n");
+
+  attach = new CalAttachment();
+  attach.encoding = "BASE64";
+  attach.uri = Services.io.newURI("data:text/plain,");
+  equal(attach.icalString, "ATTACH;ENCODING=BASE64:data:text/plain,\r\n");
+
+  throws(() => {
+    attach.icalString = "X-STICKER:smiley";
+  }, /Illegal value/);
+
+  attach = new CalAttachment();
+  attach.uri = Services.io.newURI("data:text/plain,");
+  attach.setParameter("X-PROP", "VAL");
+  equal(attach.icalString, "ATTACH;X-PROP=VAL:data:text/plain,\r\n");
+  attach.setParameter("X-PROP", null);
+  equal(attach.icalString, "ATTACH:data:text/plain,\r\n");
+}
diff --git a/comm/calendar/test/unit/test_attendee.js b/comm/calendar/test/unit/test_attendee.js
new file mode 100644
index 0000000000..55051f720b
--- /dev/null
+++ b/comm/calendar/test/unit/test_attendee.js
@@ -0,0 +1,318 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+function run_test() {
+  test_values();
+  test_serialize();
+  test_properties();
+  test_doubleParameters(); // Bug 875739
+  test_emptyAttendee();
+}
+
+function test_values() {
+  function findAttendeesInResults(event, expectedAttendees) {
+    // Getting all attendees
+    let allAttendees = event.getAttendees();
+
+    equal(allAttendees.length, expectedAttendees.length);
+
+    // Check if all expected attendees are found
+    for (let i = 0; i < expectedAttendees.length; i++) {
+      ok(allAttendees.includes(expectedAttendees[i]));
+    }
+
+    // Check if all found attendees are expected
+    for (let i = 0; i < allAttendees.length; i++) {
+      ok(expectedAttendees.includes(allAttendees[i]));
+    }
+  }
+  function findById(event, id, a) {
+    let foundAttendee = event.getAttendeeById(id);
+    equal(foundAttendee, a);
+  }
+  function testImmutability(a, properties) {
+    ok(!a.isMutable);
+    // Check if setting a property throws. It should.
+    for (let i = 0; i < properties.length; i++) {
+      let old = a[properties[i]];
+      throws(() => {
+        a[properties[i]] = old + 1;
+      }, /Can not modify immutable data container/);
+
+      equal(a[properties[i]], old);
+    }
+  }
+
+  // Create Attendee
+  let attendee1 = new CalAttendee();
+  // Testing attendee set/get.
+  let properties = ["id", "commonName", "rsvp", "role", "participationStatus", "userType"];
+  let values = ["myid", "mycn", "TRUE", "CHAIR", "DECLINED", "RESOURCE"];
+  // Make sure test is valid
+  equal(properties.length, values.length);
+
+  for (let i = 0; i < properties.length; i++) {
+    attendee1[properties[i]] = values[i];
+    equal(attendee1[properties[i]], values[i]);
+  }
+
+  // Create event
+  let event = new CalEvent();
+
+  // Add attendee to event
+  event.addAttendee(attendee1);
+
+  // Add 2nd attendee to event.
+  let attendee2 = new CalAttendee();
+  attendee2.id = "myid2";
+  event.addAttendee(attendee2);
+
+  // Finding by ID
+  findById(event, "myid", attendee1);
+  findById(event, "myid2", attendee2);
+
+  findAttendeesInResults(event, [attendee1, attendee2]);
+
+  // Making attendee immutable
+  attendee1.makeImmutable();
+  testImmutability(attendee1, properties);
+  // Testing cascaded immutability (event -> attendee)
+  event.makeImmutable();
+  testImmutability(attendee2, properties);
+
+  // Testing cloning
+  let eventClone = event.clone();
+  let clonedatts = eventClone.getAttendees();
+  let atts = event.getAttendees();
+  equal(atts.length, clonedatts.length);
+
+  for (let i = 0; i < clonedatts.length; i++) {
+    // The attributes should not be equal
+    notEqual(atts[i], clonedatts[i]);
+    // But the ids should
+    equal(atts[i].id, clonedatts[i].id);
+  }
+
+  // Make sure organizers are also cloned correctly
+  let attendee3 = new CalAttendee();
+  attendee3.id = "horst";
+  attendee3.isOrganizer = true;
+  let attendee4 = attendee3.clone();
+
+  ok(attendee4.isOrganizer);
+  attendee3.isOrganizer = false;
+  ok(attendee4.isOrganizer);
+}
+
+function test_serialize() {
+  let a = new CalAttendee();
+
+  throws(() => {
+    // eslint-disable-next-line no-unused-expressions
+    a.icalProperty;
+  }, /Component not initialized/);
+
+  a.id = "horst";
+  a.commonName = "Horst";
+  a.rsvp = "TRUE";
+
+  a.isOrganizer = false;
+
+  a.role = "CHAIR";
+  a.participationStatus = "DECLINED";
+  a.userType = "RESOURCE";
+
+  a.setProperty("X-NAME", "X-VALUE");
+
+  let prop = a.icalProperty;
+  dump(prop.icalString);
+  equal(prop.value, "horst");
+  equal(prop.propertyName, "ATTENDEE");
+  equal(prop.getParameter("CN"), "Horst");
+  equal(prop.getParameter("RSVP"), "TRUE");
+  equal(prop.getParameter("ROLE"), "CHAIR");
+  equal(prop.getParameter("PARTSTAT"), "DECLINED");
+  equal(prop.getParameter("CUTYPE"), "RESOURCE");
+  equal(prop.getParameter("X-NAME"), "X-VALUE");
+
+  a.isOrganizer = true;
+  prop = a.icalProperty;
+  equal(prop.value, "horst");
+  equal(prop.propertyName, "ORGANIZER");
+  equal(prop.getParameter("CN"), "Horst");
+  equal(prop.getParameter("RSVP"), "TRUE");
+  equal(prop.getParameter("ROLE"), "CHAIR");
+  equal(prop.getParameter("PARTSTAT"), "DECLINED");
+  equal(prop.getParameter("CUTYPE"), "RESOURCE");
+  equal(prop.getParameter("X-NAME"), "X-VALUE");
+}
+
+function test_properties() {
+  let a = new CalAttendee();
+
+  throws(() => {
+    // eslint-disable-next-line no-unused-expressions
+    a.icalProperty;
+  }, /Component not initialized/);
+
+  a.id = "horst";
+  a.commonName = "Horst";
+  a.rsvp = "TRUE";
+
+  a.isOrganizer = false;
+
+  a.role = "CHAIR";
+  a.participationStatus = "DECLINED";
+  a.userType = "RESOURCE";
+
+  // Only X-Props should show up in the enumerator
+  a.setProperty("X-NAME", "X-VALUE");
+  for (let [name, value] of a.properties) {
+    equal(name, "X-NAME");
+    equal(value, "X-VALUE");
+  }
+
+  a.deleteProperty("X-NAME");
+  for (let [name, value] of a.properties) {
+    do_throw("Unexpected property " + name + " = " + value);
+  }
+
+  a.setProperty("X-NAME", "X-VALUE");
+  a.setProperty("X-NAME", null);
+
+  for (let [name, value] of a.properties) {
+    do_throw("Unexpected property after setting null " + name + " = " + value);
+  }
+}
+
+function test_doubleParameters() {
+  function testParameters(aAttendees, aExpected) {
+    for (let attendee of aAttendees) {
+      let prop = attendee.icalProperty;
+      let parNames = [];
+      let parValues = [];
+
+      // Extract the parameters
+      for (
+        let paramName = prop.getFirstParameterName();
+        paramName;
+        paramName = prop.getNextParameterName()
+      ) {
+        parNames.push(paramName);
+        parValues.push(prop.getParameter(paramName));
+      }
+
+      // Check the results
+      let att_n = attendee.id.substr(7, 9);
+      for (let parIndex in parNames) {
+        ok(
+          aExpected[att_n].param.includes(parNames[parIndex]),
+          "Parameter " + parNames[parIndex] + " included in " + att_n
+        );
+        ok(
+          aExpected[att_n].values.includes(parValues[parIndex]),
+          "Value " + parValues[parIndex] + " for parameter " + parNames[parIndex]
+        );
+      }
+      ok(
+        parNames.length == aExpected[att_n].param.length,
+        "Each parameter has been considered for " + att_n
+      );
+    }
+  }
+
+  // Event with attendees and organizer with one of the parameter duplicated.
+  let ics = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//Marketcircle Inc.//Daylite 4.0//EN",
+    "BEGIN:VEVENT",
+    "DTSTART:20130529T100000",
+    "DTEND:20130529T110000",
+    "SUMMARY:Summary",
+    "CREATED:20130514T124220Z",
+    "DTSTAMP:20130524T101307Z",
+    "UID:9482DDFA-07B4-44B9-8228-ED4BC17BA278",
+    "SEQUENCE:3",
+    "ORGANIZER;CN=CN_organizer;X-ORACLE-GUID=A5120D71D6193E11E04400144F;",
+    " X-UW-AVAILABLE-APPOINTMENT-ROLE=OWNER;X-UW-AVAILABLE-APPOINTMENT",
+    " -ROLE=OWNER:mailto:organizer@example.com",
+    "ATTENDEE;ROLE=REQ-PARTICIPANT;RSVP=TRUE;CUTYPE=INDIVIDUAL;RSVP=TRUE;",
+    " PARTSTAT=NEEDS-ACTION;X-RECEIVED-DTSTAMP=",
+    " 20130827T124944Z;CN=CN_attendee1:mailto:attendee1@example.com",
+    "ATTENDEE;ROLE=CHAIR;CN=CN_attendee2;CUTYPE=INDIVIDUAL;",
+    " PARTSTAT=ACCEPTED;CN=CN_attendee2:mailto:attendee2@example.com",
+    "ATTENDEE;ROLE=REQ-PARTICIPANT;RSVP=TRUE;CUTYPE=RESOURCE;",
+    " PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT;CN=CN_attendee3",
+    " :mailto:attendee3@example.com",
+    'ATTENDEE;CN="CN_attendee4";PARTSTAT=ACCEPTED;X-RECEIVED-DTSTAMP=',
+    " 20130827T124944Z;X-RECEIVED-SEQUENCE=0;X-RECEIVED-SEQUENCE=0",
+    " :mailto:attendee4@example.com",
+    "END:VEVENT",
+    "END:VCALENDAR",
+  ].join("\n");
+
+  let expectedOrganizer = {
+    organizer: {
+      param: ["CN", "X-ORACLE-GUID", "X-UW-AVAILABLE-APPOINTMENT-ROLE"],
+      values: ["CN_organizer", "A5120D71D6193E11E04400144F", "OWNER"],
+    },
+  };
+  let expectedAttendee = {
+    attendee1: {
+      param: ["CN", "RSVP", "ROLE", "PARTSTAT", "CUTYPE", "X-RECEIVED-DTSTAMP"],
+      values: [
+        "CN_attendee1",
+        "TRUE",
+        "REQ-PARTICIPANT",
+        "NEEDS-ACTION",
+        "INDIVIDUAL",
+        "20130827T124944Z",
+      ],
+    },
+    attendee2: {
+      param: ["CN", "ROLE", "PARTSTAT", "CUTYPE"],
+      values: ["CN_attendee2", "CHAIR", "ACCEPTED", "INDIVIDUAL"],
+    },
+    attendee3: {
+      param: ["CN", "RSVP", "ROLE", "PARTSTAT", "CUTYPE"],
+      values: ["CN_attendee3", "TRUE", "REQ-PARTICIPANT", "NEEDS-ACTION", "RESOURCE"],
+    },
+    attendee4: {
+      param: ["CN", "PARTSTAT", "X-RECEIVED-DTSTAMP", "X-RECEIVED-SEQUENCE"],
+      values: ["CN_attendee4", "ACCEPTED", "20130827T124944Z", "0"],
+    },
+  };
+
+  let event = createEventFromIcalString(ics);
+  let organizer = [event.organizer];
+  let attendees = event.getAttendees();
+
+  testParameters(organizer, expectedOrganizer);
+  testParameters(attendees, expectedAttendee);
+}
+function test_emptyAttendee() {
+  // Event with empty attendee.
+  const event = createEventFromIcalString(
+    [
+      "BEGIN:VCALENDAR",
+      "VERSION:2.0",
+      "BEGIN:VEVENT",
+      "DTSTAMP:19700101T000000Z",
+      "DTSTART:19700101T000001Z",
+      "ATTENDEE:",
+      "END:VEVENT",
+      "END:VCALENDAR",
+    ].join("\n")
+  );
+  const attendees = event.getAttendees();
+  equal(attendees.length, 0);
+}
diff --git a/comm/calendar/test/unit/test_auth_utils.js b/comm/calendar/test/unit/test_auth_utils.js
new file mode 100644
index 0000000000..929762561e
--- /dev/null
+++ b/comm/calendar/test/unit/test_auth_utils.js
@@ -0,0 +1,100 @@
+/* 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 USERNAME = "fred";
+const PASSWORD = "********";
+const ORIGIN = "https://origin";
+const REALM = "realm";
+
+function run_test() {
+  do_get_profile();
+  run_next_test();
+}
+
+function checkLoginCount(total) {
+  Assert.equal(total, Services.logins.countLogins("", "", ""));
+}
+
+/**
+ * Tests the passwordManager{Get,Save,Remove} functions
+ */
+add_task(async function test_password_manager() {
+  await Services.logins.initializationPromise;
+  checkLoginCount(0);
+
+  // Save the password
+  cal.auth.passwordManagerSave(USERNAME, PASSWORD, ORIGIN, REALM);
+  checkLoginCount(1);
+
+  // Save again, should modify the existing login
+  cal.auth.passwordManagerSave(USERNAME, PASSWORD, ORIGIN, REALM);
+  checkLoginCount(1);
+
+  // Retrieve the saved password
+  let passout = {};
+  let found = cal.auth.passwordManagerGet(USERNAME, passout, ORIGIN, REALM);
+  Assert.equal(passout.value, PASSWORD);
+  Assert.ok(found);
+  checkLoginCount(1);
+
+  // Retrieving should still happen with signon saving disabled, but saving should not
+  Services.prefs.setBoolPref("signon.rememberSignons", false);
+  passout = {};
+  found = cal.auth.passwordManagerGet(USERNAME, passout, ORIGIN, REALM);
+  Assert.equal(passout.value, PASSWORD);
+  Assert.ok(found);
+
+  Assert.throws(
+    () => cal.auth.passwordManagerSave(USERNAME, PASSWORD, ORIGIN, REALM),
+    /NS_ERROR_NOT_AVAILABLE/
+  );
+  Services.prefs.clearUserPref("signon.rememberSignons");
+  checkLoginCount(1);
+
+  // Remove the password
+  found = cal.auth.passwordManagerRemove(USERNAME, ORIGIN, REALM);
+  checkLoginCount(0);
+  Assert.ok(found);
+
+  // Really gone?
+  found = cal.auth.passwordManagerRemove(USERNAME, ORIGIN, REALM);
+  checkLoginCount(0);
+  Assert.ok(!found);
+});
+
+/**
+ * Tests various origins that can be passed to passwordManagerSave
+ */
+add_task(async function test_password_manager_origins() {
+  await Services.logins.initializationPromise;
+  checkLoginCount(0);
+
+  // The scheme of the origin should be normalized to lowercase, this won't add any new passwords
+  cal.auth.passwordManagerSave(USERNAME, PASSWORD, "OAUTH:xpcshell@example.com", REALM);
+  checkLoginCount(1);
+  cal.auth.passwordManagerSave(USERNAME, PASSWORD, "oauth:xpcshell@example.com", REALM);
+  checkLoginCount(1);
+
+  // Make sure that the prePath isn't used for oauth, because that is only the scheme
+  let found = cal.auth.passwordManagerGet(USERNAME, {}, "oauth:", REALM);
+  Assert.ok(!found);
+
+  // Save a https url with a path (only prePath should be used)
+  cal.auth.passwordManagerSave(USERNAME, PASSWORD, "https://example.com/withpath", REALM);
+  found = cal.auth.passwordManagerGet(USERNAME, {}, "https://example.com", REALM);
+  Assert.ok(found);
+  checkLoginCount(2);
+
+  // Entering something that is not an URL should assume https
+  cal.auth.passwordManagerSave(USERNAME, PASSWORD, "example.net", REALM);
+  found = cal.auth.passwordManagerGet(USERNAME, {}, "https://example.net", REALM);
+  Assert.ok(found);
+  checkLoginCount(3);
+
+  // Cleanup
+  cal.auth.passwordManagerRemove(USERNAME, "oauth:xpcshell@example.com", REALM);
+  cal.auth.passwordManagerRemove(USERNAME, "https://example.com", REALM);
+  cal.auth.passwordManagerRemove(USERNAME, "https://example.net", REALM);
+  checkLoginCount(0);
+});
diff --git a/comm/calendar/test/unit/test_bug1199942.js b/comm/calendar/test/unit/test_bug1199942.js
new file mode 100644
index 0000000000..7d78cb1244
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug1199942.js
@@ -0,0 +1,81 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+function run_test() {
+  // Test the graceful handling of attendee ids for bug 1199942
+  createAttendee_test();
+  serializeEvent_test();
+}
+
+function createAttendee_test() {
+  let data = [
+    { input: "mailto:user1@example.net", expected: "mailto:user1@example.net" },
+    { input: "MAILTO:user2@example.net", expected: "mailto:user2@example.net" },
+    { input: "user3@example.net", expected: "mailto:user3@example.net" },
+    { input: "urn:uuid:user4", expected: "urn:uuid:user4" },
+  ];
+  let event = new CalEvent();
+  for (let test of data) {
+    let attendee = new CalAttendee();
+    attendee.id = test.input;
+    event.addAttendee(attendee);
+    let readAttendee = event.getAttendeeById(cal.email.prependMailTo(test.input));
+    equal(readAttendee.id, test.expected);
+  }
+}
+
+function serializeEvent_test() {
+  let ics =
+    "BEGIN:VCALENDAR\n" +
+    "PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN\n" +
+    "VERSION:2.0\n" +
+    "BEGIN:VEVENT\n" +
+    "CREATED:20150801T213509Z\n" +
+    "LAST-MODIFIED:20150830T164104Z\n" +
+    "DTSTAMP:20150830T164104Z\n" +
+    "UID:a84c74d1-cfc6-4ddf-9d60-9e4afd8238cf\n" +
+    "SUMMARY:New Event\n" +
+    "ORGANIZER;RSVP=TRUE;CN=Tester1;PARTSTAT=ACCEPTED;ROLE=CHAIR:mailto:user1@example.net\n" +
+    "ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT:MAILTO:user2@example.net\n" +
+    "ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT:mailto:user3@example.net\n" +
+    "ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT:user4@example.net\n" +
+    "ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT:urn:uuid:user5\n" +
+    "DTSTART:20150729T103000Z\n" +
+    "DTEND:20150729T113000Z\n" +
+    "TRANSP:OPAQUE\n" +
+    "END:VEVENT\n" +
+    "END:VCALENDAR\n";
+
+  let expectedIds = [
+    "mailto:user2@example.net",
+    "mailto:user3@example.net",
+    "mailto:user4@example.net",
+    "urn:uuid:user5",
+  ];
+  let event = createEventFromIcalString(ics);
+  let attendees = event.getAttendees();
+
+  // check whether all attendees get returned with expected id
+  for (let attendee of attendees) {
+    ok(expectedIds.includes(attendee.id));
+  }
+
+  // serialize the event again and check whether the attendees still are in shape
+  let serializer = Cc["@mozilla.org/calendar/ics-serializer;1"].createInstance(
+    Ci.calIIcsSerializer
+  );
+  serializer.addItems([event]);
+  let serialized = ics_unfoldline(serializer.serializeToString());
+  for (let id of expectedIds) {
+    ok(serialized.search(id) != -1);
+  }
+}
diff --git a/comm/calendar/test/unit/test_bug1204255.js b/comm/calendar/test/unit/test_bug1204255.js
new file mode 100644
index 0000000000..9277378ec4
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug1204255.js
@@ -0,0 +1,146 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+function run_test() {
+  // Test attendee duplicate handling for bug 1204255
+  test_newAttendee();
+  test_fromICS();
+}
+
+function test_newAttendee() {
+  let data = [
+    {
+      input: [
+        { id: "user2@example.net", partstat: "NEEDS-ACTION", cname: "NOT PREFIXED" },
+        { id: "mailto:user2@example.net", partstat: "NEEDS-ACTION", cname: "PREFIXED" },
+      ],
+      expected: { id: "mailto:user2@example.net", partstat: "NEEDS-ACTION", cname: "PREFIXED" },
+    },
+    {
+      input: [
+        { id: "mailto:user3@example.net", partstat: "NEEDS-ACTION", cname: "PREFIXED" },
+        { id: "user3@example.net", partstat: "NEEDS-ACTION", cname: "NOT PREFIXED" },
+      ],
+      expected: { id: "mailto:user3@example.net", partstat: "NEEDS-ACTION", cname: "NOT PREFIXED" },
+    },
+    {
+      input: [
+        { id: "mailto:user4@example.net", partstat: "ACCEPTED", cname: "PREFIXED" },
+        { id: "user4@example.net", partstat: "TENTATIVE", cname: "NOT PREFIXED" },
+      ],
+      expected: { id: "mailto:user4@example.net", partstat: "ACCEPTED", cname: "PREFIXED" },
+    },
+    {
+      input: [
+        { id: "user5@example.net", partstat: "TENTATIVE", cname: "NOT PREFIXED" },
+        { id: "mailto:user5@example.net", partstat: "ACCEPTED", cname: "PREFIXED" },
+      ],
+      expected: { id: "mailto:user5@example.net", partstat: "TENTATIVE", cname: "NOT PREFIXED" },
+    },
+    {
+      input: [
+        { id: "user6@example.net", partstat: "DECLINED", cname: "NOT PREFIXED" },
+        { id: "mailto:user6@example.net", partstat: "TENTATIVE", cname: "PREFIXED" },
+      ],
+      expected: { id: "mailto:user6@example.net", partstat: "DECLINED", cname: "NOT PREFIXED" },
+    },
+    {
+      input: [
+        { id: "user7@example.net", partstat: "TENTATIVE", cname: "NOT PREFIXED" },
+        { id: "mailto:user7@example.net", partstat: "DECLINED", cname: "PREFIXED" },
+      ],
+      expected: { id: "mailto:user7@example.net", partstat: "DECLINED", cname: "PREFIXED" },
+    },
+  ];
+
+  let event = new CalEvent();
+  for (let test of data) {
+    for (let input of test.input) {
+      let attendee = new CalAttendee();
+      attendee.id = input.id;
+      attendee.participationStatus = input.partstat;
+      attendee.commonName = input.cname;
+      event.addAttendee(attendee);
+    }
+    let readAttendee = event.getAttendeeById(cal.email.prependMailTo(test.expected.id));
+    equal(readAttendee.id, test.expected.id);
+    equal(
+      readAttendee.participationStatus,
+      test.expected.partstat,
+      "partstat matches for " + test.expected.id
+    );
+    equal(
+      readAttendee.commonName,
+      test.expected.cname,
+      "commonName matches for " + test.expected.id
+    );
+  }
+}
+
+function test_fromICS() {
+  let ics = [
+    "BEGIN:VCALENDAR",
+    "PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN",
+    "VERSION:2.0",
+    "BEGIN:VEVENT",
+    "UID:a84c74d1-cfc6-4ddf-9d60-9e4afd8238cf",
+    "SUMMARY:New Event",
+    "DTSTART:20150729T103000Z",
+    "DTEND:20150729T113000Z",
+    "ORGANIZER;RSVP=TRUE;CN=Tester1;PARTSTAT=ACCEPTED;ROLE=CHAIR:mailto:user1@example.net",
+
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;CN="NOT PREFIXED";ROLE=REQ-PARTICIPANT:user2@example.net',
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;CN="PREFIXED";ROLE=REQ-PARTICIPANT:mailto:user2@example.net',
+
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;CN="PREFIXED";ROLE=REQ-PARTICIPANT:mailto:user3@example.net',
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;CN="NOT PREFIXED";ROLE=REQ-PARTICIPANT:user3@example.net',
+
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=ACCEPTED;CN="PREFIXED";ROLE=REQ-PARTICIPANT:mailto:user4@example.net',
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=TENTATIVE;CN="NOT PREFIXED";ROLE=REQ-PARTICIPANT:user4@example.net',
+
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=TENTATIVE;CN="NOT PREFIXED";ROLE=REQ-PARTICIPANT:user5@example.net',
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=ACCEPTED;CN="PREFIXED";ROLE=REQ-PARTICIPANT:mailto:user5@example.net',
+
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=DECLINED;CN="NOT PREFIXED";ROLE=REQ-PARTICIPANT:user6@example.net',
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=TENTATIVE;CN="PREFIXED";ROLE=REQ-PARTICIPANT:mailto:user6@example.net',
+
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=TENTATIVE;CN="NOT PREFIXED";ROLE=REQ-PARTICIPANT:user7@example.net',
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=DECLINED;CN="PREFIXED";ROLE=REQ-PARTICIPANT:mailto:user7@example.net',
+    "END:VEVENT",
+    "END:VCALENDAR",
+  ].join("\n");
+
+  let expected = [
+    { id: "mailto:user2@example.net", partstat: "NEEDS-ACTION", cname: "PREFIXED" },
+    { id: "mailto:user3@example.net", partstat: "NEEDS-ACTION", cname: "NOT PREFIXED" },
+    { id: "mailto:user4@example.net", partstat: "ACCEPTED", cname: "PREFIXED" },
+    { id: "mailto:user5@example.net", partstat: "TENTATIVE", cname: "NOT PREFIXED" },
+    { id: "mailto:user6@example.net", partstat: "DECLINED", cname: "NOT PREFIXED" },
+    { id: "mailto:user7@example.net", partstat: "DECLINED", cname: "PREFIXED" },
+  ];
+  let event = createEventFromIcalString(ics);
+  let attendees = event.getAttendees();
+
+  // check whether all attendees get returned as expected
+  equal(attendees.length, expected.length);
+  let count = 0;
+  for (let attendee of attendees) {
+    for (let exp of expected) {
+      if (attendee.id == exp.id) {
+        equal(attendee.participationStatus, exp.partstat, "partstat matches for " + exp.id);
+        equal(attendee.commonName, exp.cname, "commonName matches for " + exp.id);
+        count++;
+      }
+    }
+  }
+  equal(count, expected.length, "all attendees were processed");
+}
diff --git a/comm/calendar/test/unit/test_bug1209399.js b/comm/calendar/test/unit/test_bug1209399.js
new file mode 100644
index 0000000000..6392f25867
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug1209399.js
@@ -0,0 +1,117 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+function run_test() {
+  // Test handling for multiple double quotes leading/trailing to attendee CN for bug 1209399
+  test_newAttendee();
+  test_fromICS();
+}
+
+function test_newAttendee() {
+  let data = [
+    {
+      input: { cname: null, id: "mailto:user1@example.net" },
+      expected: { cname: null },
+    },
+    {
+      input: { cname: "Test2", id: "mailto:user2@example.net" },
+      expected: { cname: "Test2" },
+    },
+    {
+      input: { cname: '"Test3"', id: "mailto:user3@example.net" },
+      expected: { cname: "Test3" },
+    },
+    {
+      input: { cname: '""Test4""', id: "mailto:user4@example.net" },
+      expected: { cname: "Test4" },
+    },
+    {
+      input: { cname: '""Test5"', id: "mailto:user5@example.net" },
+      expected: { cname: "Test5" },
+    },
+    {
+      input: { cname: '"Test6""', id: "mailto:user6@example.net" },
+      expected: { cname: "Test6" },
+    },
+    {
+      input: { cname: "", id: "mailto:user7@example.net" },
+      expected: { cname: "" },
+    },
+    {
+      input: { cname: '""', id: "mailto:user8@example.net" },
+      expected: { cname: null },
+    },
+    {
+      input: { cname: '""""', id: "mailto:user9@example.net" },
+      expected: { cname: null },
+    },
+  ];
+
+  let i = 0;
+  let event = new CalEvent();
+  for (let test of data) {
+    i++;
+    let attendee = new CalAttendee();
+    attendee.id = test.input.id;
+    attendee.commonName = test.input.cname;
+
+    event.addAttendee(attendee);
+    let readAttendee = event.getAttendeeById(test.input.id);
+    equal(
+      readAttendee.commonName,
+      test.expected.cname,
+      "Test #" + i + " for commonName matching of " + test.input.id
+    );
+  }
+}
+
+function test_fromICS() {
+  let ics = [
+    "BEGIN:VCALENDAR",
+    "PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN",
+    "VERSION:2.0",
+    "BEGIN:VEVENT",
+    "UID:a84c74d1-cfc6-4ddf-9d60-9e4afd8238cf",
+    "SUMMARY:New Event",
+    "DTSTART:20150729T103000Z",
+    "DTEND:20150729T113000Z",
+    "ORGANIZER;RSVP=TRUE;CN=Tester1;PARTSTAT=ACCEPTED;ROLE=CHAIR:mailto:user1@example.net",
+
+    "ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;CN=Test2;ROLE=REQ-PARTICIPANT:mailto:user2@example.net",
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;CN="Test3";ROLE=REQ-PARTICIPANT:mailto:user3@example.net',
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;CN=""Test4"";ROLE=REQ-PARTICIPANT:mailto:user4@example.net',
+    "ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;CN=;ROLE=REQ-PARTICIPANT:mailto:user5@example.net",
+    "ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT:mailto:user6@example.net",
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;CN="";ROLE=REQ-PARTICIPANT:mailto:user7@example.net',
+    'ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;CN="""";ROLE=REQ-PARTICIPANT:mailto:user8@example.net',
+
+    "END:VEVENT",
+    "END:VCALENDAR",
+  ].join("\n");
+
+  let expected = [
+    { id: "mailto:user2@example.net", cname: "Test2" },
+    { id: "mailto:user3@example.net", cname: "Test3" },
+    { id: "mailto:user4@example.net", cname: "" },
+    { id: "mailto:user5@example.net", cname: "" },
+    { id: "mailto:user6@example.net", cname: null },
+    { id: "mailto:user7@example.net", cname: "" },
+    { id: "mailto:user8@example.net", cname: "" },
+  ];
+  let event = createEventFromIcalString(ics);
+
+  equal(event.getAttendees().length, expected.length, "Check test consistency");
+  for (let exp of expected) {
+    let attendee = event.getAttendeeById(exp.id);
+    equal(attendee.commonName, exp.cname, "Test for commonName matching of " + exp.id);
+  }
+}
diff --git a/comm/calendar/test/unit/test_bug1790339.js b/comm/calendar/test/unit/test_bug1790339.js
new file mode 100644
index 0000000000..4d2bed95ce
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug1790339.js
@@ -0,0 +1,71 @@
+/* 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 () => {
+  let dbFile = do_get_profile();
+  dbFile.append("test_storage.sqlite");
+
+  let sql = await IOUtils.readUTF8(do_get_file("data/bug1790339.sql").path);
+  let db = Services.storage.openDatabase(dbFile);
+  db.executeSimpleSQL(sql);
+  db.close();
+
+  await new Promise(resolve => {
+    do_calendar_startup(resolve);
+  });
+
+  let calendar = Cc["@mozilla.org/calendar/calendar;1?type=storage"].createInstance(
+    Ci.calISyncWriteCalendar
+  );
+  calendar.uri = Services.io.newFileURI(dbFile);
+  calendar.id = "00000000-0000-0000-0000-000000000000";
+
+  checkItem(await calendar.getItem("00000000-0000-0000-0000-111111111111"));
+  checkItem(await calendar.getItem("00000000-0000-0000-0000-222222222222"));
+});
+
+function checkItem(item) {
+  info(`Checking item ${item.id}`);
+
+  let attachments = item.getAttachments();
+  Assert.equal(attachments.length, 1);
+  let attach = attachments[0];
+  Assert.equal(
+    attach.uri.spec,
+    "https://ftp.mozilla.org/pub/thunderbird/nightly/latest-comm-central/thunderbird-106.0a1.en-US.linux-x86_64.tar.bz2"
+  );
+
+  let attendees = item.getAttendees();
+  Assert.equal(attendees.length, 1);
+  let attendee = attendees[0];
+  Assert.equal(attendee.id, "mailto:test@example.com");
+  Assert.equal(attendee.role, "REQ-PARTICIPANT");
+  Assert.equal(attendee.participationStatus, "NEEDS-ACTION");
+
+  let recurrenceItems = item.recurrenceInfo.getRecurrenceItems();
+  Assert.equal(recurrenceItems.length, 1);
+  let recurrenceItem = recurrenceItems[0];
+  Assert.equal(recurrenceItem.type, "WEEKLY");
+  Assert.equal(recurrenceItem.interval, 22);
+  Assert.equal(recurrenceItem.isByCount, false);
+  Assert.equal(recurrenceItem.isFinite, true);
+  Assert.deepEqual(recurrenceItem.getComponent("BYDAY"), [2, 3, 4, 5, 6, 7, 1]);
+  Assert.equal(recurrenceItem.isNegative, false);
+
+  let relations = item.getRelations();
+  Assert.equal(relations.length, 1);
+  let relation = relations[0];
+  Assert.equal(relation.relType, "SIBLING");
+  Assert.equal(relation.relId, "19960401-080045-4000F192713@example.com");
+
+  let alarms = item.getAlarms();
+  Assert.equal(alarms.length, 1);
+  let alarm = alarms[0];
+  Assert.equal(alarm.action, "DISPLAY");
+  Assert.equal(alarm.offset.inSeconds, -300);
+  Assert.equal(
+    alarm.description,
+    "Make sure you don't miss this very very important event. It's essential that you don't forget."
+  );
+}
diff --git a/comm/calendar/test/unit/test_bug272411.js b/comm/calendar/test/unit/test_bug272411.js
new file mode 100644
index 0000000000..c871b53cf0
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug272411.js
@@ -0,0 +1,15 @@
+/* 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 run_test() {
+  let jsd = new Date();
+  let cdt = cal.dtz.jsDateToDateTime(jsd);
+
+  let cdtTime = cal.dtz.dateTimeToJsDate(cdt).getTime() / 1000;
+  let jsdTime = Math.floor(jsd.getTime() / 1000);
+
+  // calIDateTime is only accurate to the second, milliseconds need to be
+  // stripped.
+  equal(cdtTime, jsdTime);
+}
diff --git a/comm/calendar/test/unit/test_bug343792.js b/comm/calendar/test/unit/test_bug343792.js
new file mode 100644
index 0000000000..c212315af3
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug343792.js
@@ -0,0 +1,66 @@
+/* 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 run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  // Check that Bug 343792 doesn't regress:
+  // Freeze (hang) on RRULE which has INTERVAL=0
+
+  let icalString =
+    "BEGIN:VCALENDAR\n" +
+    "CALSCALE:GREGORIAN\n" +
+    "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n" +
+    "VERSION:2.0\n" +
+    "BEGIN:VTIMEZONE\n" +
+    "TZID:/softwarestudio.org/Olson_20011030_5/America/Los_Angeles\n" +
+    "X-LIC-LOCATION:America/Los_Angeles\n" +
+    "BEGIN:STANDARD\n" +
+    "TZOFFSETFROM:-0700\n" +
+    "TZOFFSETTO:-0800\n" +
+    "TZNAME:PST\n" +
+    "DTSTART:19701025T020000\n" +
+    "RRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU;INTERVAL=1\n" +
+    "END:STANDARD\n" +
+    "BEGIN:DAYLIGHT\n" +
+    "TZOFFSETFROM:-0800\n" +
+    "TZOFFSETTO:-0700\n" +
+    "TZNAME:PDT\n" +
+    "DTSTART:19700405T020000\n" +
+    "RRULE:FREQ=YEARLY;BYMONTH=4;BYDAY=1SU;INTERVAL=1\n" +
+    "END:DAYLIGHT\n" +
+    "END:VTIMEZONE\n" +
+    "BEGIN:VEVENT\n" +
+    "UID:20060705T145529-1768-1244-1267-46@localhost\n" +
+    "ORGANIZER:MAILTO:No Body\n" +
+    "DTSTAMP:20060705T145529Z\n" +
+    "DTSTART;TZID=/softwarestudio.org/Olson_20011030_5/America/Los_Angeles:\n" +
+    " 20060515T170000\n" +
+    "DTEND;TZID=/softwarestudio.org/Olson_20011030_5/America/Los_Angeles:\n" +
+    " 20060515T173000\n" +
+    "RRULE:FREQ=WEEKLY;INTERVAL=0\n" +
+    "LOCATION:Maui Building\n" +
+    "TRANSP:OPAQUE\n" +
+    "SEQUENCE:0\n" +
+    "SUMMARY:FW development Status\n" +
+    "PRIORITY:4\n" +
+    "CLASS:PUBLIC\n" +
+    "DESCRIPTION:Daily standup Mtg and/or status update on FW\n" +
+    "END:VEVENT\n" +
+    "END:VCALENDAR";
+
+  let event = createEventFromIcalString(icalString);
+  let start = createDate(2009, 4, 1);
+  let end = createDate(2009, 4, 30);
+
+  // the following call caused a never ending loop:
+  let occurrenceDates = event.recurrenceInfo.getOccurrenceDates(start, end, 0);
+  equal(occurrenceDates.length, 4);
+
+  // the following call caused a never ending loop:
+  let occurrences = event.recurrenceInfo.getOccurrences(start, end, 0);
+  equal(occurrences.length, 4);
+}
diff --git a/comm/calendar/test/unit/test_bug350845.js b/comm/calendar/test/unit/test_bug350845.js
new file mode 100644
index 0000000000..735f4b6eb4
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug350845.js
@@ -0,0 +1,43 @@
+/* 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 run_test() {
+  let event = createEventFromIcalString(
+    "BEGIN:VEVENT\n" +
+      "UID:182d2719-fe2a-44c1-9210-0286b16c0538\n" +
+      "X-FOO;X-BAR=BAZ:QUUX\n" +
+      "END:VEVENT"
+  );
+
+  // Test getters for imported event
+  equal(event.getProperty("X-FOO"), "QUUX");
+  ok(event.hasProperty("X-FOO"));
+  equal(event.getPropertyParameter("X-FOO", "X-BAR"), "BAZ");
+  ok(event.hasPropertyParameter("X-FOO", "X-BAR"));
+
+  // Test setters
+  throws(() => {
+    event.setPropertyParameter("X-UNKNOWN", "UNKNOWN", "VALUE");
+  }, /Property X-UNKNOWN not set/);
+
+  // More setters
+  event.setPropertyParameter("X-FOO", "X-BAR", "FNORD");
+  equal(event.getPropertyParameter("X-FOO", "X-BAR"), "FNORD");
+  notEqual(event.icalString.match(/^X-FOO;X-BAR=FNORD:QUUX$/m), null);
+
+  // Test we can get the parameter names
+  throws(() => {
+    event.getParameterNames("X-UNKNOWN");
+  }, /Property X-UNKNOWN not set/);
+  equal(event.getParameterNames("X-FOO").length, 1);
+  ok(event.getParameterNames("X-FOO").includes("X-BAR"));
+
+  // Deletion of parameters when deleting properties
+  event.deleteProperty("X-FOO");
+  ok(!event.hasProperty("X-FOO"));
+  event.setProperty("X-FOO", "SNORK");
+  equal(event.getProperty("X-FOO"), "SNORK");
+  equal(event.getParameterNames("X-FOO").length, 0);
+  equal(event.getPropertyParameter("X-FOO", "X-BAR"), null);
+}
diff --git a/comm/calendar/test/unit/test_bug356207.js b/comm/calendar/test/unit/test_bug356207.js
new file mode 100644
index 0000000000..1ad23c6acd
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug356207.js
@@ -0,0 +1,47 @@
+/* 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 run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  // Check that Bug 356207 doesn't regress:
+  // Freeze (hang) on RRULE which has BYMONTHDAY and BYDAY
+
+  let icalString =
+    "BEGIN:VCALENDAR\n" +
+    "PRODID:-//Randy L Pearson//NONSGML Outlook2vCal V1.1//EN\n" +
+    "VERSION:2.0\n" +
+    "BEGIN:VEVENT\n" +
+    "CREATED:20040829T163323\n" +
+    "UID:00000000EBFAC68C9B92BF119D643623FBD17E1424312000\n" +
+    "SEQUENCE:1\n" +
+    "LAST-MODIFIED:20060615T231158\n" +
+    "DTSTAMP:20040829T163323\n" +
+    "ORGANIZER:Unknown\n" +
+    "DTSTART:20040901T141500\n" +
+    "DESCRIPTION:Contact Mary Tindall for more details.\n" +
+    "CLASS:PUBLIC\n" +
+    "LOCATION:Church\n" +
+    "CATEGORIES:Church Events\n" +
+    "SUMMARY:Friendship Circle\n" +
+    "PRIORITY:1\n" +
+    "DTEND:20040901T141500\n" +
+    "RRULE:FREQ=MONTHLY;INTERVAL=1;BYMONTHDAY=1;BYDAY=WE\n" +
+    "END:VEVENT\n" +
+    "END:VCALENDAR";
+
+  let event = createEventFromIcalString(icalString);
+  let start = createDate(2009, 0, 1);
+  let end = createDate(2009, 11, 31);
+
+  // the following call caused a never ending loop:
+  let occurrenceDates = event.recurrenceInfo.getOccurrenceDates(start, end, 0);
+  equal(occurrenceDates.length, 2);
+
+  // the following call caused a never ending loop:
+  let occurrences = event.recurrenceInfo.getOccurrences(start, end, 0);
+  equal(occurrences.length, 2);
+}
diff --git a/comm/calendar/test/unit/test_bug485571.js b/comm/calendar/test/unit/test_bug485571.js
new file mode 100644
index 0000000000..855109b7e8
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug485571.js
@@ -0,0 +1,99 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAlarm: "resource:///modules/CalAlarm.jsm",
+});
+
+function run_test() {
+  // Check that the RELATED property is correctly set
+  // after parsing the given VALARM component
+
+  // trigger set 15 minutes prior to the start of the event
+  check_relative(
+    "BEGIN:VALARM\n" +
+      "ACTION:DISPLAY\n" +
+      "TRIGGER:-PT15M\n" +
+      "DESCRIPTION:TEST\n" +
+      "END:VALARM",
+    Ci.calIAlarm.ALARM_RELATED_START
+  );
+
+  // trigger set 15 minutes prior to the start of the event
+  check_relative(
+    "BEGIN:VALARM\n" +
+      "ACTION:DISPLAY\n" +
+      "TRIGGER;VALUE=DURATION:-PT15M\n" +
+      "DESCRIPTION:TEST\n" +
+      "END:VALARM",
+    Ci.calIAlarm.ALARM_RELATED_START
+  );
+
+  // trigger set 15 minutes prior to the start of the event
+  check_relative(
+    "BEGIN:VALARM\n" +
+      "ACTION:DISPLAY\n" +
+      "TRIGGER;RELATED=START:-PT15M\n" +
+      "DESCRIPTION:TEST\n" +
+      "END:VALARM",
+    Ci.calIAlarm.ALARM_RELATED_START
+  );
+
+  // trigger set 15 minutes prior to the start of the event
+  check_relative(
+    "BEGIN:VALARM\n" +
+      "ACTION:DISPLAY\n" +
+      "TRIGGER;VALUE=DURATION;RELATED=START:-PT15M\n" +
+      "DESCRIPTION:TEST\n" +
+      "END:VALARM",
+    Ci.calIAlarm.ALARM_RELATED_START
+  );
+
+  // trigger set 5 minutes after the end of an event
+  check_relative(
+    "BEGIN:VALARM\n" +
+      "ACTION:DISPLAY\n" +
+      "TRIGGER;RELATED=END:PT5M\n" +
+      "DESCRIPTION:TEST\n" +
+      "END:VALARM",
+    Ci.calIAlarm.ALARM_RELATED_END
+  );
+
+  // trigger set 5 minutes after the end of an event
+  check_relative(
+    "BEGIN:VALARM\n" +
+      "ACTION:DISPLAY\n" +
+      "TRIGGER;VALUE=DURATION;RELATED=END:PT5M\n" +
+      "DESCRIPTION:TEST\n" +
+      "END:VALARM",
+    Ci.calIAlarm.ALARM_RELATED_END
+  );
+
+  // trigger set to an absolute date/time
+  check_absolute(
+    "BEGIN:VALARM\n" +
+      "ACTION:DISPLAY\n" +
+      "TRIGGER;VALUE=DATE-TIME:20090430T080000Z\n" +
+      "DESCRIPTION:TEST\n" +
+      "END:VALARM"
+  );
+}
+
+function check_relative(aIcalString, aRelated) {
+  let alarm = new CalAlarm();
+  alarm.icalString = aIcalString;
+  equal(alarm.related, aRelated);
+  equal(alarm.alarmDate, null);
+  notEqual(alarm.offset, null);
+}
+
+function check_absolute(aIcalString) {
+  let alarm = new CalAlarm();
+  alarm.icalString = aIcalString;
+  equal(alarm.related, Ci.calIAlarm.ALARM_RELATED_ABSOLUTE);
+  ok(alarm.alarmDate != null);
+  equal(alarm.offset, null);
+}
diff --git a/comm/calendar/test/unit/test_bug486186.js b/comm/calendar/test/unit/test_bug486186.js
new file mode 100644
index 0000000000..cf25594790
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug486186.js
@@ -0,0 +1,21 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAlarm: "resource:///modules/CalAlarm.jsm",
+});
+
+function run_test() {
+  // ensure that RELATED property is correctly set on the VALARM component
+  let alarm = new CalAlarm();
+  alarm.action = "DISPLAY";
+  alarm.description = "test";
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_END;
+  alarm.offset = cal.createDuration("-PT15M");
+  if (alarm.icalString.search(/RELATED=END/) == -1) {
+    do_throw("Bug 486186: RELATED property missing in VALARM component");
+  }
+}
diff --git a/comm/calendar/test/unit/test_bug494140.js b/comm/calendar/test/unit/test_bug494140.js
new file mode 100644
index 0000000000..9a5baa6956
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug494140.js
@@ -0,0 +1,57 @@
+/* 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/. */
+
+/**
+ * In bug 494140 we found out that creating an exception to a series duplicates
+ * alarms. This unit test makes sure the alarms don't duplicate themselves. The
+ * same goes for relations and attachments.
+ */
+add_task(async () => {
+  let storageCal = getStorageCal();
+
+  let item = createEventFromIcalString(
+    "BEGIN:VEVENT\r\n" +
+      "CREATED:20090603T171401Z\r\n" +
+      "LAST-MODIFIED:20090617T080410Z\r\n" +
+      "DTSTAMP:20090617T080410Z\r\n" +
+      "UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5\r\n" +
+      "SUMMARY:Test\r\n" +
+      "DTSTART:20090603T073000Z\r\n" +
+      "DTEND:20090603T091500Z\r\n" +
+      "RRULE:FREQ=DAILY;COUNT=5\r\n" +
+      "RELATED-TO:RELTYPE=SIBLING:<foo@example.org>\r\n" +
+      "ATTACH:http://www.example.org/\r\n" +
+      "BEGIN:VALARM\r\n" +
+      "ACTION:DISPLAY\r\n" +
+      "TRIGGER;VALUE=DURATION:-PT10M\r\n" +
+      "DESCRIPTION:Mozilla Alarm: Test\r\n" +
+      "END:VALARM\r\n" +
+      "END:VEVENT"
+  );
+
+  // There should be one alarm, one relation and one attachment
+  equal(item.getAlarms().length, 1);
+  equal(item.getRelations().length, 1);
+  equal(item.getAttachments().length, 1);
+
+  // Change the occurrence to another day
+  let occ = item.recurrenceInfo.getOccurrenceFor(cal.createDateTime("20090604T073000Z"));
+  occ.QueryInterface(Ci.calIEvent);
+  occ.startDate = cal.createDateTime("20090618T073000Z");
+  item.recurrenceInfo.modifyException(occ, true);
+
+  // There should still be one alarm, one relation and one attachment
+  equal(item.getAlarms().length, 1);
+  equal(item.getRelations().length, 1);
+  equal(item.getAttachments().length, 1);
+
+  // Add the item to the storage calendar and retrieve it again
+  await storageCal.adoptItem(item);
+
+  let retrievedItem = await storageCal.getItem("c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5");
+  // There should still be one alarm, one relation and one attachment
+  equal(retrievedItem.getAlarms().length, 1);
+  equal(retrievedItem.getRelations().length, 1);
+  equal(retrievedItem.getAttachments().length, 1);
+});
diff --git a/comm/calendar/test/unit/test_bug523860.js b/comm/calendar/test/unit/test_bug523860.js
new file mode 100644
index 0000000000..c5455eda3d
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug523860.js
@@ -0,0 +1,15 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+function run_test() {
+  // In bug 523860, we found out that in the spec doublequotes should not be
+  // escaped.
+  let prop = cal.icsService.createIcalProperty("DESCRIPTION");
+  let expected = "A String with \"quotes\" and 'other quotes'";
+
+  prop.value = expected;
+  equal(prop.icalString, "DESCRIPTION:" + expected + "\r\n");
+}
diff --git a/comm/calendar/test/unit/test_bug653924.js b/comm/calendar/test/unit/test_bug653924.js
new file mode 100644
index 0000000000..1573ae54aa
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug653924.js
@@ -0,0 +1,20 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalRelation: "resource:///modules/CalRelation.jsm",
+});
+
+function run_test() {
+  const evt = new CalEvent();
+  const rel = new CalRelation("RELATED-TO:2424d594-0453-49a1-b842-6faee483ca79");
+  evt.addRelation(rel);
+
+  equal(1, evt.icalString.match(/RELATED-TO/g).length);
+  evt.icalString = evt.icalString; // eslint-disable-line no-self-assign
+  equal(1, evt.icalString.match(/RELATED-TO/g).length);
+}
diff --git a/comm/calendar/test/unit/test_bug668222.js b/comm/calendar/test/unit/test_bug668222.js
new file mode 100644
index 0000000000..eb6e9f5d0b
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug668222.js
@@ -0,0 +1,28 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+});
+
+function run_test() {
+  let attendee = new CalAttendee();
+  attendee.id = "mailto:somebody";
+
+  // Set the property and make sure its there
+  attendee.setProperty("SCHEDULE-AGENT", "CLIENT");
+  equal(attendee.getProperty("SCHEDULE-AGENT"), "CLIENT");
+
+  // Reserialize the property, this has caused the property to go away
+  // in the past.
+  attendee.icalProperty = attendee.icalProperty; // eslint-disable-line no-self-assign
+  equal(attendee.getProperty("SCHEDULE-AGENT"), "CLIENT");
+
+  // Also make sure there are no promoted properties set. This does not
+  // technically belong to this bug, but I almost caused this error while
+  // writing the patch.
+  ok(!attendee.icalProperty.icalString.includes("RSVP"));
+}
diff --git a/comm/calendar/test/unit/test_bug759324.js b/comm/calendar/test/unit/test_bug759324.js
new file mode 100644
index 0000000000..e2dabcd9f9
--- /dev/null
+++ b/comm/calendar/test/unit/test_bug759324.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/. */
+
+let storage = getStorageCal();
+
+/**
+ * Checks if the capabilities.propagate-sequence feature of the storage calendar
+ * still works
+ */
+add_task(async function testBug759324() {
+  storage.setProperty("capabilities.propagate-sequence", "true");
+
+  let str = [
+    "BEGIN:VEVENT",
+    "UID:recItem",
+    "SEQUENCE:3",
+    "RRULE:FREQ=WEEKLY",
+    "DTSTART:20120101T010101Z",
+    "END:VEVENT",
+  ].join("\r\n");
+
+  let item = createEventFromIcalString(str);
+  let rid = cal.createDateTime("20120101T010101Z");
+  let rec = item.recurrenceInfo.getOccurrenceFor(rid);
+  rec.title = "changed";
+  item.recurrenceInfo.modifyException(rec, true);
+
+  do_test_pending();
+
+  let addedItem = await storage.addItem(item);
+  addedItem.QueryInterface(Ci.calIEvent);
+  let seq = addedItem.getProperty("SEQUENCE");
+  let occ = addedItem.recurrenceInfo.getOccurrenceFor(rid);
+
+  equal(seq, 3);
+  equal(occ.getProperty("SEQUENCE"), seq);
+
+  let changedItem = addedItem.clone();
+  changedItem.setProperty("SEQUENCE", parseInt(seq, 10) + 1);
+
+  checkModifiedItem(rid, await storage.modifyItem(changedItem, addedItem));
+});
+
+async function checkModifiedItem(rid, changedItem) {
+  changedItem.QueryInterface(Ci.calIEvent);
+  let seq = changedItem.getProperty("SEQUENCE");
+  let occ = changedItem.recurrenceInfo.getOccurrenceFor(rid);
+
+  equal(seq, 4);
+  equal(occ.getProperty("SEQUENCE"), seq);
+
+  // Now check with the pref off
+  storage.deleteProperty("capabilities.propagate-sequence");
+
+  let changedItem2 = changedItem.clone();
+  changedItem2.setProperty("SEQUENCE", parseInt(seq, 10) + 1);
+
+  checkNormalItem(rid, await storage.modifyItem(changedItem2, changedItem));
+}
+
+function checkNormalItem(rid, changedItem) {
+  changedItem.QueryInterface(Ci.calIEvent);
+  let seq = changedItem.getProperty("SEQUENCE");
+  let occ = changedItem.recurrenceInfo.getOccurrenceFor(rid);
+
+  equal(seq, 5);
+  equal(occ.getProperty("SEQUENCE"), 4);
+  completeTest();
+}
+
+function completeTest() {
+  do_test_finished();
+}
diff --git a/comm/calendar/test/unit/test_calIteratorUtils.js b/comm/calendar/test/unit/test_calIteratorUtils.js
new file mode 100644
index 0000000000..db5158d6c9
--- /dev/null
+++ b/comm/calendar/test/unit/test_calIteratorUtils.js
@@ -0,0 +1,38 @@
+/* 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/. */
+
+/**
+ * Tests for cal.iterate.*
+ */
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { CalReadableStreamFactory } = ChromeUtils.import(
+  "resource:///modules/CalReadableStreamFactory.jsm"
+);
+
+/**
+ * Test streamValues() iterates over all values found in a stream.
+ */
+add_task(async function testStreamValues() {
+  let src = Array(10)
+    .fill(null)
+    .map((_, i) => i + 1);
+  let stream = CalReadableStreamFactory.createReadableStream({
+    start(controller) {
+      for (let i = 0; i < src.length; i++) {
+        controller.enqueue(src[i]);
+      }
+      controller.close();
+    },
+  });
+
+  let dest = [];
+  for await (let value of cal.iterate.streamValues(stream)) {
+    dest.push(value);
+  }
+  Assert.ok(
+    src.every((val, idx) => (dest[idx] = val)),
+    "all values were read from the stream"
+  );
+});
diff --git a/comm/calendar/test/unit/test_calStorageHelpers.js b/comm/calendar/test/unit/test_calStorageHelpers.js
new file mode 100644
index 0000000000..b7b3d54f04
--- /dev/null
+++ b/comm/calendar/test/unit/test_calStorageHelpers.js
@@ -0,0 +1,23 @@
+const { newDateTime } = ChromeUtils.import("resource:///modules/calendar/calStorageHelpers.jsm");
+
+add_task(async function testNewDateTimeWithIcalTimezoneDef() {
+  // Define a timezone that is unlikely to match anything in common use
+  const icalTimezoneDef = `BEGIN:VTIMEZONE
+TZID:Totally_Made_Up_Standard_Time
+BEGIN:STANDARD
+DTSTART:19671029T020000
+TZOFFSETFROM:-0427
+TZOFFSETTO:-0527
+END:STANDARD
+END:VTIMEZONE`;
+
+  // 6 October, 2022 at 17:23:08 UTC
+  const dateTime = newDateTime(1665076988000000, icalTimezoneDef);
+
+  Assert.equal(dateTime.year, 2022, "year should be 2022");
+  Assert.equal(dateTime.month, 9, "zero-based month should be October");
+  Assert.equal(dateTime.day, 6, "day should be the 6th");
+  Assert.equal(dateTime.hour, 11, "hour should be 11 AM");
+  Assert.equal(dateTime.minute, 56, "minute should be 56");
+  Assert.equal(dateTime.second, 8, "second should be 8");
+});
diff --git a/comm/calendar/test/unit/test_caldav_requests.js b/comm/calendar/test/unit/test_caldav_requests.js
new file mode 100644
index 0000000000..2f46c09a8d
--- /dev/null
+++ b/comm/calendar/test/unit/test_caldav_requests.js
@@ -0,0 +1,970 @@
+/* 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 { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+
+var { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
+var { MockRegistrar } = ChromeUtils.importESModule(
+  "resource://testing-common/MockRegistrar.sys.mjs"
+);
+
+var {
+  CalDavGenericRequest,
+  CalDavItemRequest,
+  CalDavDeleteItemRequest,
+  CalDavPropfindRequest,
+  CalDavHeaderRequest,
+  CalDavPrincipalPropertySearchRequest,
+  CalDavOutboxRequest,
+  CalDavFreeBusyRequest,
+} = ChromeUtils.import("resource:///modules/caldav/CalDavRequest.jsm");
+var { CalDavWebDavSyncHandler } = ChromeUtils.import(
+  "resource:///modules/caldav/CalDavRequestHandlers.jsm"
+);
+
+var { CalDavSession } = ChromeUtils.import("resource:///modules/caldav/CalDavSession.jsm");
+var { CalDavXmlns } = ChromeUtils.import("resource:///modules/caldav/CalDavUtils.jsm");
+var { Preferences } = ChromeUtils.importESModule("resource://gre/modules/Preferences.sys.mjs");
+var { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+class LowerMap extends Map {
+  get(key) {
+    return super.get(key.toLowerCase());
+  }
+  set(key, value) {
+    return super.set(key.toLowerCase(), value);
+  }
+}
+
+var gServer;
+
+var MockConflictPrompt = {
+  _origFunc: null,
+  overwrite: false,
+  register() {
+    if (!this._origFunc) {
+      this._origFunc = cal.provider.promptOverwrite;
+      cal.provider.promptOverwrite = (aMode, aItem) => {
+        return this.overwrite;
+      };
+    }
+  },
+
+  unregister() {
+    if (this._origFunc) {
+      cal.provider.promptOverwrite = this._origFunc;
+      this._origFunc = null;
+    }
+  },
+};
+
+class MockAlertsService {
+  QueryInterface = ChromeUtils.generateQI(["nsIAlertsService"]);
+  showAlert() {}
+}
+
+function replaceAlertsService() {
+  let originalAlertsServiceCID = MockRegistrar.register(
+    "@mozilla.org/alerts-service;1",
+    MockAlertsService
+  );
+  registerCleanupFunction(() => {
+    MockRegistrar.unregister(originalAlertsServiceCID);
+  });
+}
+
+var gMockCalendar = {
+  name: "xpcshell",
+  makeUri(insert, base) {
+    return base;
+  },
+  verboseLogging() {
+    return true;
+  },
+  ensureEncodedPath(x) {
+    return x;
+  },
+  ensureDecodedPath(x) {
+    return x;
+  },
+  startBatch() {},
+  endBatch() {},
+  addTargetCalendarItem() {},
+  finalizeUpdatedItems() {},
+  mHrefIndex: [],
+};
+gMockCalendar.superCalendar = gMockCalendar;
+
+class CalDavServer {
+  constructor(calendarId) {
+    this.server = new HttpServer();
+    this.calendarId = calendarId;
+    this.session = new CalDavSession(this.calendarId, "xpcshell");
+    this.serverRequests = {};
+
+    this.server.registerPrefixHandler(
+      "/principals/",
+      this.router.bind(this, this.principals.bind(this))
+    );
+    this.server.registerPrefixHandler(
+      "/calendars/",
+      this.router.bind(this, this.calendars.bind(this))
+    );
+    this.server.registerPrefixHandler(
+      "/requests/",
+      this.router.bind(this, this.requests.bind(this))
+    );
+  }
+
+  start() {
+    this.server.start(-1);
+    registerCleanupFunction(() => this.server.stop(() => {}));
+  }
+
+  reset() {
+    this.serverRequests = {};
+  }
+
+  uri(path) {
+    let base = Services.io.newURI(`http://localhost:${this.server.identity.primaryPort}/`);
+    return Services.io.newURI(path, null, base);
+  }
+
+  router(nextHandler, request, response) {
+    try {
+      let method = request.method;
+      let parameters = new Map(request.queryString.split("&").map(part => part.split("=", 2)));
+      let available = request.bodyInputStream.available();
+      let body =
+        available > 0 ? NetUtil.readInputStreamToString(request.bodyInputStream, available) : null;
+
+      let headers = new LowerMap();
+
+      let headerIterator = function* (enumerator) {
+        while (enumerator.hasMoreElements()) {
+          yield enumerator.getNext().QueryInterface(Ci.nsISupportsString);
+        }
+      };
+
+      for (let hdr of headerIterator(request.headers)) {
+        headers.set(hdr.data, request.getHeader(hdr.data));
+      }
+
+      return nextHandler(request, response, method, headers, parameters, body);
+    } catch (e) {
+      info("Server Error: " + e.fileName + ":" + e.lineNumber + ": " + e + "\n");
+      return null;
+    }
+  }
+
+  resetClient(client) {
+    MockConflictPrompt.unregister();
+    cal.manager.unregisterCalendar(client);
+  }
+
+  waitForLoad(aCalendar) {
+    return new Promise((resolve, reject) => {
+      let observer = cal.createAdapter(Ci.calIObserver, {
+        onLoad() {
+          let uncached = aCalendar.wrappedJSObject.mUncachedCalendar.wrappedJSObject;
+          aCalendar.removeObserver(observer);
+
+          if (Components.isSuccessCode(uncached._lastStatus)) {
+            resolve(aCalendar);
+          } else {
+            reject(uncached._lastMessage);
+          }
+        },
+      });
+      aCalendar.addObserver(observer);
+    });
+  }
+
+  getClient() {
+    let uri = this.uri("/calendars/xpcshell/events");
+    let client = cal.manager.createCalendar("caldav", uri);
+    let uclient = client.wrappedJSObject;
+    client.name = "xpcshell";
+    client.setProperty("cache.enabled", true);
+
+    // Make sure we catch the last error message in case sync fails
+    monkeyPatch(uclient, "replayChangesOn", (protofunc, aListener) => {
+      protofunc({
+        onResult(operation, detail) {
+          uclient._lastStatus = operation.status;
+          uclient._lastMessage = detail;
+          aListener.onResult(operation, detail);
+        },
+      });
+    });
+
+    cal.manager.registerCalendar(client);
+
+    let cachedCalendar = cal.manager.getCalendarById(client.id);
+    return this.waitForLoad(cachedCalendar);
+  }
+
+  principals(request, response, method, headers, parameters, body) {
+    this.serverRequests.principals = { method, headers, parameters, body };
+
+    if (method == "REPORT" && request.path == "/principals/") {
+      response.setHeader("Content-Type", "application/xml");
+      response.write(dedent`
+        <?xml version="1.0" encoding="utf-8" ?>
+        <D:multistatus xmlns:D="DAV:" xmlns:B="http://BigCorp.com/ns/">
+          <D:response>
+            <D:href>http://www.example.com/users/jdoe</D:href>
+            <D:propstat>
+              <D:prop>
+                <D:displayname>John Doe</D:displayname>
+                <B:department>Widget Sales</B:department>
+                <B:phone>234-4567</B:phone>
+                <B:office>209</B:office>
+              </D:prop>
+              <D:status>HTTP/1.1 200 OK</D:status>
+            </D:propstat>
+            <D:propstat>
+              <D:prop>
+                <B:salary/>
+              </D:prop>
+              <D:status>HTTP/1.1 403 Forbidden</D:status>
+            </D:propstat>
+          </D:response>
+          <D:response>
+            <D:href>http://www.example.com/users/zsmith</D:href>
+            <D:propstat>
+              <D:prop>
+                <D:displayname>Zygdoebert Smith</D:displayname>
+                <B:department>Gadget Sales</B:department>
+                <B:phone>234-7654</B:phone>
+                <B:office>114</B:office>
+              </D:prop>
+              <D:status>HTTP/1.1 200 OK</D:status>
+            </D:propstat>
+            <D:propstat>
+              <D:prop>
+                <B:salary/>
+              </D:prop>
+              <D:status>HTTP/1.1 403 Forbidden</D:status>
+            </D:propstat>
+          </D:response>
+        </D:multistatus>
+      `);
+      response.setStatusLine(null, 207, "Multistatus");
+    } else if (method == "PROPFIND" && request.path == "/principals/xpcshell/user/") {
+      response.setHeader("Content-Type", "application/xml");
+      response.write(dedent`
+        <?xml version="1.0" encoding="utf-8"?>
+        <D:multistatus xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav">
+          <D:response>
+            <D:href>${this.uri("/principals/xpcshell/user").spec}</D:href>
+            <D:propstat>
+              <D:prop>
+                <C:calendar-home-set>
+                  <D:href>${this.uri("/calendars/xpcshell/user/").spec}</D:href>
+                </C:calendar-home-set>
+                <C:calendar-user-address-set>
+                  <D:href>mailto:xpcshell@example.com</D:href>
+                </C:calendar-user-address-set>
+                <C:schedule-inbox-URL>
+                  <D:href>${this.uri("/calendars/xpcshell/inbox").spec}/</D:href>
+                </C:schedule-inbox-URL>
+                <C:schedule-outbox-URL>
+                  <D:href>${this.uri("/calendars/xpcshell/outbox").spec}</D:href>
+                </C:schedule-outbox-URL>
+              </D:prop>
+              <D:status>HTTP/1.1 200 OK</D:status>
+            </D:propstat>
+          </D:response>
+        </D:multistatus>
+      `);
+      response.setStatusLine(null, 207, "Multistatus");
+    }
+  }
+
+  calendars(request, response, method, headers, parameters, body) {
+    this.serverRequests.calendars = { method, headers, parameters, body };
+
+    if (
+      method == "PROPFIND" &&
+      request.path.startsWith("/calendars/xpcshell/events") &&
+      headers.get("depth") == 0
+    ) {
+      response.setHeader("Content-Type", "application/xml");
+      response.write(dedent`
+        <?xml version="1.0" encoding="utf-8" ?>
+        <D:multistatus ${CalDavXmlns("D", "C", "CS")} xmlns:R="http://www.foo.bar/boxschema/">
+          <D:response>
+            <D:href>${request.path}</D:href>
+            <D:propstat>
+              <D:prop>
+                <D:resourcetype>
+                  <D:collection/>
+                  <C:calendar/>
+                </D:resourcetype>
+                <R:plain-text-prop>hello, world</R:plain-text-prop>
+                <D:principal-collection-set>
+                  <D:href>${this.uri("/principals/").spec}</D:href>
+                  <D:href>${this.uri("/principals/subthing/").spec}</D:href>
+                </D:principal-collection-set>
+                <D:current-user-principal>
+                  <D:href>${this.uri("/principals/xpcshell/user").spec}</D:href>
+                </D:current-user-principal>
+                <D:supported-report-set>
+                  <D:supported-report>
+                    <D:report>
+                      <D:principal-property-search/>
+                    </D:report>
+                  </D:supported-report>
+                  <D:supported-report>
+                    <D:report>
+                      <C:calendar-multiget/>
+                    </D:report>
+                  </D:supported-report>
+                  <D:supported-report>
+                    <D:report>
+                      <D:sync-collection/>
+                    </D:report>
+                  </D:supported-report>
+                </D:supported-report-set>
+                <C:supported-calendar-component-set>
+                  <C:comp name="VEVENT"/>
+                  <C:comp name="VTODO"/>
+                </C:supported-calendar-component-set>
+                <C:schedule-inbox-URL>
+                  <D:href>${this.uri("/calendars/xpcshell/inbox").spec}</D:href>
+                </C:schedule-inbox-URL>
+                <C:schedule-outbox-URL>
+                  ${this.uri("/calendars/xpcshell/outbox").spec}
+                </C:schedule-outbox-URL>
+                <CS:getctag>1413647159-1007960</CS:getctag>
+              </D:prop>
+              <D:status>HTTP/1.1 200 OK</D:status>
+            </D:propstat>
+            <D:propstat>
+              <D:prop>
+                <R:obscure-thing-not-found/>
+              </D:prop>
+              <D:status>HTTP/1.1 404 Not Found</D:status>
+            </D:propstat>
+          </D:response>
+        </D:multistatus>
+      `);
+      response.setStatusLine(null, 207, "Multistatus");
+    } else if (method == "POST" && request.path == "/calendars/xpcshell/outbox") {
+      response.setHeader("Content-Type", "application/xml");
+      response.write(dedent`
+        <?xml version="1.0" encoding="utf-8" ?>
+        <C:schedule-response ${CalDavXmlns("D", "C")}>
+          <D:response>
+            <D:href>mailto:recipient1@example.com</D:href>
+            <D:request-status>2.0;Success</D:request-status>
+          </D:response>
+          <D:response>
+            <D:href>mailto:recipient2@example.com</D:href>
+            <D:request-status>2.0;Success</D:request-status>
+          </D:response>
+        </C:schedule-response>
+      `);
+      response.setStatusLine(null, 200, "OK");
+    } else if (method == "POST" && request.path == "/calendars/xpcshell/outbox2") {
+      response.setHeader("Content-Type", "application/xml");
+      response.write(dedent`
+        <?xml version="1.0" encoding="utf-8" ?>
+        <C:schedule-response ${CalDavXmlns("D", "C")}>
+          <D:response>
+            <D:recipient>
+              <D:href>mailto:recipient1@example.com</D:href>
+            </D:recipient>
+            <D:request-status>2.0;Success</D:request-status>
+            <C:calendar-data>
+        BEGIN:VCALENDAR
+        PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN
+        VERSION:2.0
+        METHOD:REQUEST
+        BEGIN:VFREEBUSY
+        DTSTART;VALUE=DATE:20180102
+        DTEND;VALUE=DATE:20180126
+        ORGANIZER:mailto:xpcshell@example.com
+        ATTENDEE;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL:mail
+          to:recipient@example.com
+        FREEBUSY;FBTYPE=FREE:20180103T010101Z/20180117T010101Z
+        FREEBUSY;FBTYPE=BUSY:20180118T010101Z/P7D
+        END:VFREEBUSY
+        END:VCALENDAR
+            </C:calendar-data>
+          </D:response>
+        </C:schedule-response>
+      `);
+      response.setStatusLine(null, 200, "OK");
+    } else if (method == "OPTIONS" && request.path == "/calendars/xpcshell/") {
+      response.setHeader(
+        "DAV",
+        "1, 2, 3, access-control, extended-mkcol, resource-sharing, calendar-access, calendar-auto-schedule, calendar-query-extended, calendar-availability, calendarserver-sharing, inbox-availability"
+      );
+      response.setStatusLine(null, 200, "OK");
+    } else if (method == "REPORT" && request.path == "/calendars/xpcshell/events/") {
+      response.setHeader("Content-Type", "application/xml");
+      let bodydom = cal.xml.parseString(body);
+      let report = bodydom.documentElement.localName;
+      let eventName = String.fromCharCode(...new TextEncoder().encode("イベント"));
+      if (report == "sync-collection") {
+        response.write(dedent`
+          <?xml version="1.0" encoding="utf-8" ?>
+          <D:multistatus ${CalDavXmlns("D")}>
+            <D:response>
+              <D:href>${this.uri("/calendars/xpcshell/events/test.ics").spec}</D:href>
+              <D:propstat>
+                <D:prop>
+                  <D:getcontenttype>text/calendar; charset=utf-8; component=VEVENT</D:getcontenttype>
+                  <D:getetag>"2decee6ffb701583398996bfbdacb8eec53edf94"</D:getetag>
+                  <D:displayname>${eventName}</D:displayname>
+                </D:prop>
+                <D:status>HTTP/1.1 200 OK</D:status>
+              </D:propstat>
+            </D:response>
+          </D:multistatus>
+        `);
+      } else if (report == "calendar-multiget") {
+        let event = new CalEvent();
+        event.title = "会議";
+        event.startDate = cal.dtz.now();
+        event.endDate = cal.dtz.now();
+        let icalString = String.fromCharCode(...new TextEncoder().encode(event.icalString));
+        response.write(dedent`
+          <?xml version="1.0" encoding="utf-8"?>
+          <D:multistatus ${CalDavXmlns("D", "C")}>
+            <D:response>
+              <D:href>${this.uri("/calendars/xpcshell/events/test.ics").spec}</D:href>
+              <D:propstat>
+                <D:prop>
+                  <D:getetag>"2decee6ffb701583398996bfbdacb8eec53edf94"</D:getetag>
+                  <C:calendar-data>${icalString}</C:calendar-data>
+                </D:prop>
+              </D:propstat>
+            </D:response>
+          </D:multistatus>
+        `);
+      }
+      response.setStatusLine(null, 207, "Multistatus");
+    } else {
+      console.log("XXX: " + method, request.path, [...headers.entries()]);
+    }
+  }
+
+  requests(request, response, method, headers, parameters, body) {
+    // ["", "requests", "generic"] := /requests/generic
+    let parts = request.path.split("/");
+    let id = parts[2];
+    let status = parseInt(parts[3] || "", 10) || 200;
+
+    if (id == "redirected") {
+      response.setHeader("Location", "/requests/redirected-target", false);
+      status = 302;
+    } else if (id == "dav") {
+      response.setHeader("DAV", "1, calendar-schedule, calendar-auto-schedule");
+    }
+
+    this.serverRequests[id] = { method, headers, parameters, body };
+
+    for (let [hdr, value] of headers.entries()) {
+      response.setHeader(hdr, "response-" + value, false);
+    }
+
+    response.setHeader("Content-Type", "application/xml");
+    response.write(`<response id="${id}">xpc</response>`);
+    response.setStatusLine(null, status, null);
+  }
+}
+
+function run_test() {
+  Preferences.set("calendar.debug.log", true);
+  Preferences.set("calendar.debug.log.verbose", true);
+  cal.console.maxLogLevel = "debug";
+  replaceAlertsService();
+
+  // TODO: make do_calendar_startup to work with this test and replace the startup code here
+  do_get_profile();
+  do_test_pending();
+
+  cal.manager.startup({
+    onResult() {
+      gServer = new CalDavServer("xpcshell@example.com");
+      gServer.start();
+      cal.timezoneService.startup({
+        onResult() {
+          run_next_test();
+          do_test_finished();
+        },
+      });
+    },
+  });
+}
+
+add_task(async function test_caldav_session() {
+  gServer.reset();
+
+  let prepared = 0;
+  let redirected = 0;
+  let completed = 0;
+  let restart = false;
+
+  gServer.session.authAdapters.localhost = {
+    async prepareRequest(aChannel) {
+      prepared++;
+    },
+
+    async prepareRedirect(aOldChannel, aNewChannel) {
+      redirected++;
+    },
+
+    async completeRequest(aResponse) {
+      completed++;
+      if (restart) {
+        restart = false;
+        return CalDavSession.RESTART_REQUEST;
+      }
+      return null;
+    },
+  };
+
+  // First a simple request
+  let uri = gServer.uri("/requests/session");
+  let request = new CalDavGenericRequest(gServer.session, gMockCalendar, "HEAD", uri);
+  await request.commit();
+
+  equal(prepared, 1);
+  equal(redirected, 0);
+  equal(completed, 1);
+
+  // Now a redirect
+  prepared = redirected = completed = 0;
+
+  uri = gServer.uri("/requests/redirected");
+  request = new CalDavGenericRequest(gServer.session, gMockCalendar, "HEAD", uri);
+  await request.commit();
+
+  equal(prepared, 1);
+  equal(redirected, 1);
+  equal(completed, 1);
+
+  // Now with restarting the request
+  prepared = redirected = completed = 0;
+  restart = true;
+
+  uri = gServer.uri("/requests/redirected");
+  request = new CalDavGenericRequest(gServer.session, gMockCalendar, "HEAD", uri);
+  await request.commit();
+
+  equal(prepared, 2);
+  equal(redirected, 2);
+  equal(completed, 2);
+});
+
+/**
+ * This test covers both GenericRequest and the base class CalDavRequestBase/CalDavResponseBase
+ */
+add_task(async function test_generic_request() {
+  gServer.reset();
+  let uri = gServer.uri("/requests/generic");
+  let headers = { "X-Hdr": "exists" };
+  let request = new CalDavGenericRequest(
+    gServer.session,
+    gMockCalendar,
+    "PUT",
+    uri,
+    headers,
+    "<body>xpc</body>",
+    "text/plain"
+  );
+
+  strictEqual(request.uri.spec, uri.spec);
+  strictEqual(request.session.id, gServer.session.id);
+  strictEqual(request.calendar, gMockCalendar);
+  strictEqual(request.uploadData, "<body>xpc</body>");
+  strictEqual(request.contentType, "text/plain");
+  strictEqual(request.response, null);
+  strictEqual(request.getHeader("X-Hdr"), null); // Only works after commit
+
+  let response = await request.commit();
+
+  ok(!!request.response);
+  equal(request.getHeader("X-Hdr"), "exists");
+
+  equal(response.uri.spec, uri.spec);
+  ok(!response.redirected);
+  equal(response.status, 200);
+  equal(response.statusCategory, 2);
+  ok(response.ok);
+  ok(!response.clientError);
+  ok(!response.conflict);
+  ok(!response.notFound);
+  ok(!response.serverError);
+  equal(response.text, '<response id="generic">xpc</response>');
+  equal(response.xml.documentElement.localName, "response");
+  equal(response.getHeader("X-Hdr"), "response-exists");
+
+  let serverResult = gServer.serverRequests.generic;
+
+  equal(serverResult.method, "PUT");
+  equal(serverResult.headers.get("x-hdr"), "exists");
+  equal(serverResult.headers.get("content-type"), "text/plain");
+  equal(serverResult.body, "<body>xpc</body>");
+});
+
+add_task(async function test_generic_redirected_request() {
+  gServer.reset();
+  let uri = gServer.uri("/requests/redirected");
+  let headers = {
+    Depth: 1,
+    Originator: "o",
+    Recipient: "r",
+    "If-None-Match": "*",
+    "If-Match": "123",
+  };
+  let request = new CalDavGenericRequest(
+    gServer.session,
+    gMockCalendar,
+    "PUT",
+    uri,
+    headers,
+    "<body>xpc</body>",
+    "text/plain"
+  );
+
+  let response = await request.commit();
+
+  ok(response.redirected);
+  equal(response.status, 200);
+  equal(response.text, '<response id="redirected-target">xpc</response>');
+  equal(response.xml.documentElement.getAttribute("id"), "redirected-target");
+
+  ok(gServer.serverRequests.redirected);
+  ok(gServer.serverRequests["redirected-target"]);
+
+  let results = gServer.serverRequests.redirected;
+  equal(results.headers.get("Depth"), 1);
+  equal(results.headers.get("Originator"), "o");
+  equal(results.headers.get("Recipient"), "r");
+  equal(results.headers.get("If-None-Match"), "*");
+  equal(results.headers.get("If-Match"), "123");
+
+  results = gServer.serverRequests["redirected-target"];
+  equal(results.headers.get("Depth"), 1);
+  equal(results.headers.get("Originator"), "o");
+  equal(results.headers.get("Recipient"), "r");
+  equal(results.headers.get("If-None-Match"), "*");
+  equal(results.headers.get("If-Match"), "123");
+
+  equal(response.lastRedirectStatus, 302);
+});
+
+add_task(async function test_item_request() {
+  gServer.reset();
+  let uri = gServer.uri("/requests/item/201");
+  let icalString = "BEGIN:VEVENT\r\nUID:123\r\nEND:VEVENT";
+  let componentString = `BEGIN:VCALENDAR\r\nPRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN\r\nVERSION:2.0\r\n${icalString}\r\nEND:VCALENDAR\r\n`;
+  let request = new CalDavItemRequest(
+    gServer.session,
+    gMockCalendar,
+    uri,
+    new CalEvent(icalString),
+    "*"
+  );
+  let response = await request.commit();
+
+  equal(response.status, 201);
+  ok(response.ok);
+
+  let serverResult = gServer.serverRequests.item;
+
+  equal(serverResult.method, "PUT");
+  equal(serverResult.body, componentString);
+  equal(serverResult.headers.get("If-None-Match"), "*");
+  ok(!serverResult.headers.has("If-Match"));
+
+  // Now the same with 204 No Content and an etag
+  gServer.reset();
+  uri = gServer.uri("/requests/item/204");
+  request = new CalDavItemRequest(
+    gServer.session,
+    gMockCalendar,
+    uri,
+    new CalEvent(icalString),
+    "123123"
+  );
+  response = await request.commit();
+
+  equal(response.status, 204);
+  ok(response.ok);
+
+  serverResult = gServer.serverRequests.item;
+
+  equal(serverResult.method, "PUT");
+  equal(serverResult.body, componentString);
+  equal(serverResult.headers.get("If-Match"), "123123");
+  ok(!serverResult.headers.has("If-None-Match"));
+
+  // Now the same with 200 OK and no etag
+  gServer.reset();
+  uri = gServer.uri("/requests/item/200");
+  request = new CalDavItemRequest(gServer.session, gMockCalendar, uri, new CalEvent(icalString));
+  response = await request.commit();
+
+  equal(response.status, 200);
+  ok(response.ok);
+
+  serverResult = gServer.serverRequests.item;
+
+  equal(serverResult.method, "PUT");
+  equal(serverResult.body, componentString);
+  ok(!serverResult.headers.has("If-Match"));
+  ok(!serverResult.headers.has("If-None-Match"));
+});
+
+add_task(async function test_delete_item_request() {
+  gServer.reset();
+  let uri = gServer.uri("/requests/deleteitem");
+  let request = new CalDavDeleteItemRequest(gServer.session, gMockCalendar, uri, "*");
+
+  strictEqual(request.uploadData, null);
+  strictEqual(request.contentType, null);
+
+  let response = await request.commit();
+
+  equal(response.status, 200);
+  ok(response.ok);
+
+  let serverResult = gServer.serverRequests.deleteitem;
+
+  equal(serverResult.method, "DELETE");
+  equal(serverResult.headers.get("If-Match"), "*");
+  ok(!serverResult.headers.has("If-None-Match"));
+
+  // Now the same with no etag, and a (valid) 404 response
+  gServer.reset();
+  uri = gServer.uri("/requests/deleteitem/404");
+  request = new CalDavDeleteItemRequest(gServer.session, gMockCalendar, uri);
+  response = await request.commit();
+
+  equal(response.status, 404);
+  ok(response.ok);
+
+  serverResult = gServer.serverRequests.deleteitem;
+
+  equal(serverResult.method, "DELETE");
+  ok(!serverResult.headers.has("If-Match"));
+  ok(!serverResult.headers.has("If-None-Match"));
+});
+
+add_task(async function test_propfind_request() {
+  gServer.reset();
+  let uri = gServer.uri("/calendars/xpcshell/events");
+  let props = [
+    "D:principal-collection-set",
+    "D:current-user-principal",
+    "D:supported-report-set",
+    "C:supported-calendar-component-set",
+    "C:schedule-inbox-URL",
+    "C:schedule-outbox-URL",
+    "R:obscure-thing-not-found",
+  ];
+  let request = new CalDavPropfindRequest(gServer.session, gMockCalendar, uri, props);
+  let response = await request.commit();
+
+  equal(response.status, 207);
+  ok(response.ok);
+
+  let results = gServer.serverRequests.calendars;
+
+  ok(
+    results.body.match(/<D:prop>\s*<D:principal-collection-set\/>\s*<D:current-user-principal\/>/)
+  );
+
+  equal(Object.keys(response.data).length, 1);
+  ok(!!response.data[uri.filePath]);
+  ok(!!response.firstProps);
+
+  let resprops = response.firstProps;
+
+  deepEqual(resprops["D:principal-collection-set"], [
+    gServer.uri("/principals/").spec,
+    gServer.uri("/principals/subthing/").spec,
+  ]);
+  equal(resprops["D:current-user-principal"], gServer.uri("/principals/xpcshell/user").spec);
+
+  deepEqual(
+    [...resprops["D:supported-report-set"].values()],
+    ["D:principal-property-search", "C:calendar-multiget", "D:sync-collection"]
+  );
+
+  deepEqual([...resprops["C:supported-calendar-component-set"].values()], ["VEVENT", "VTODO"]);
+  equal(resprops["C:schedule-inbox-URL"], gServer.uri("/calendars/xpcshell/inbox").spec);
+  equal(resprops["C:schedule-outbox-URL"], gServer.uri("/calendars/xpcshell/outbox").spec);
+  strictEqual(resprops["R:obscure-thing-not-found"], null);
+  equal(resprops["R:plain-text-prop"], "hello, world");
+});
+
+add_task(async function test_davheader_request() {
+  gServer.reset();
+  let uri = gServer.uri("/requests/dav");
+  let request = new CalDavHeaderRequest(gServer.session, gMockCalendar, uri);
+  let response = await request.commit();
+
+  let serverResult = gServer.serverRequests.dav;
+
+  equal(serverResult.method, "OPTIONS");
+  deepEqual([...response.features], ["calendar-schedule", "calendar-auto-schedule"]);
+  strictEqual(response.version, 1);
+});
+
+add_task(async function test_propsearch_request() {
+  gServer.reset();
+  let uri = gServer.uri("/principals/");
+  let props = ["D:displayname", "B:department", "B:phone", "B:office"];
+  let request = new CalDavPrincipalPropertySearchRequest(
+    gServer.session,
+    gMockCalendar,
+    uri,
+    "doE",
+    "D:displayname",
+    props
+  );
+  let response = await request.commit();
+
+  equal(response.status, 207);
+  ok(response.ok);
+
+  equal(response.data["http://www.example.com/users/jdoe"]["D:displayname"], "John Doe");
+
+  ok(gServer.serverRequests.principals.body.includes("<D:match>doE</D:match>"));
+  ok(gServer.serverRequests.principals.body.match(/<D:prop>\s*<D:displayname\/>\s*<\/D:prop>/));
+  ok(
+    gServer.serverRequests.principals.body.match(/<D:prop>\s*<D:displayname\/>\s*<B:department\/>/)
+  );
+});
+
+add_task(async function test_outbox_request() {
+  gServer.reset();
+  let icalString = "BEGIN:VEVENT\r\nUID:123\r\nEND:VEVENT";
+  let uri = gServer.uri("/calendars/xpcshell/outbox");
+  let request = new CalDavOutboxRequest(
+    gServer.session,
+    gMockCalendar,
+    uri,
+    "xpcshell@example.com",
+    ["recipient1@example.com", "recipient2@example.com"],
+    "REPLY",
+    new CalEvent(icalString)
+  );
+  let response = await request.commit();
+
+  equal(response.status, 200);
+  ok(response.ok);
+
+  let results = gServer.serverRequests.calendars;
+
+  ok(results.body.includes("METHOD:REPLY"));
+  equal(results.method, "POST");
+  equal(results.headers.get("Originator"), "xpcshell@example.com");
+  equal(results.headers.get("Recipient"), "recipient1@example.com, recipient2@example.com");
+});
+
+add_task(async function test_freebusy_request() {
+  gServer.reset();
+  let uri = gServer.uri("/calendars/xpcshell/outbox2");
+  let request = new CalDavFreeBusyRequest(
+    gServer.session,
+    gMockCalendar,
+    uri,
+    "mailto:xpcshell@example.com",
+    "mailto:recipient@example.com",
+    cal.createDateTime("20180101"),
+    cal.createDateTime("20180201")
+  );
+
+  let response = await request.commit();
+
+  equal(response.status, 200);
+  ok(response.ok);
+
+  let results = gServer.serverRequests.calendars;
+  equal(
+    ics_unfoldline(
+      results.body
+        .replace(/\r\n/g, "\n")
+        .replace(/(UID|DTSTAMP):[^\n]+\n/g, "")
+        .trim()
+    ),
+    dedent`
+      BEGIN:VCALENDAR
+      PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN
+      VERSION:2.0
+      METHOD:REQUEST
+      BEGIN:VFREEBUSY
+      DTSTART;VALUE=DATE:20180101
+      DTEND;VALUE=DATE:20180201
+      ORGANIZER:mailto:xpcshell@example.com
+      ATTENDEE;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL:mailto:recipient@example.com
+      END:VFREEBUSY
+      END:VCALENDAR
+    `
+  );
+  equal(results.method, "POST");
+  equal(results.headers.get("Content-Type"), "text/calendar; charset=utf-8");
+  equal(results.headers.get("Originator"), "mailto:xpcshell@example.com");
+  equal(results.headers.get("Recipient"), "mailto:recipient@example.com");
+
+  let first = response.firstRecipient;
+  equal(first.status, "2.0;Success");
+  deepEqual(
+    first.intervals.map(interval => interval.type),
+    ["UNKNOWN", "FREE", "BUSY", "UNKNOWN"]
+  );
+  deepEqual(
+    first.intervals.map(interval => interval.begin.icalString + ":" + interval.end.icalString),
+    [
+      "20180101:20180102",
+      "20180103T010101Z:20180117T010101Z",
+      "20180118T010101Z:20180125T010101Z",
+      "20180126:20180201",
+    ]
+  );
+});
+
+add_task(async function test_caldav_client() {
+  let client = await gServer.getClient();
+  let items = await client.getItemsAsArray(Ci.calICalendar.ITEM_FILTER_ALL_ITEMS, 0, null, null);
+
+  equal(items.length, 1);
+  equal(items[0].title, "会議");
+});
+
+/**
+ * Test non-ASCII text in the XML response is parsed correctly in CalDavWebDavSyncHandler.
+ */
+add_task(async function test_caldav_sync() {
+  gServer.reset();
+  let uri = gServer.uri("/calendars/xpcshell/events/");
+  gMockCalendar.session = gServer.session;
+  let webDavSync = new CalDavWebDavSyncHandler(gMockCalendar, uri);
+  await webDavSync.doWebDAVSync();
+  ok(webDavSync.logXML.includes("イベント"), "Non-ASCII text should be parsed correctly");
+});
+
+add_task(function test_can_get_google_adapter() {
+  // Initialize a session with bogus values
+  const session = new CalDavSession("xpcshell@example.com", "xpcshell");
+
+  // We don't have a facility for actually testing our Google CalDAV requests,
+  // but we can at least verify that the adapter looks okay at a glance
+  equal(
+    session.authAdapters["apidata.googleusercontent.com"].authorizationEndpoint,
+    "https://accounts.google.com/o/oauth2/auth"
+  );
+});
diff --git a/comm/calendar/test/unit/test_calmgr.js b/comm/calendar/test/unit/test_calmgr.js
new file mode 100644
index 0000000000..e4d09db0a3
--- /dev/null
+++ b/comm/calendar/test/unit/test_calmgr.js
@@ -0,0 +1,411 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { CalReadableStreamFactory } = ChromeUtils.import(
+  "resource:///modules/CalReadableStreamFactory.jsm"
+);
+var { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+/**
+ * Tests the calICalendarManager interface
+ */
+function run_test() {
+  do_calendar_startup(run_next_test);
+}
+
+class CalendarManagerObserver {
+  QueryInterface = ChromeUtils.generateQI(["calICalendarManager"]);
+
+  constructor() {
+    this.reset();
+  }
+
+  reset() {
+    this.registered = [];
+    this.unregistering = [];
+    this.deleting = [];
+  }
+
+  check({ unregistering, registered, deleting }) {
+    equal(this.unregistering[0], unregistering);
+    equal(this.registered[0], registered);
+    equal(this.deleting[0], deleting);
+
+    this.reset();
+  }
+
+  onCalendarRegistered(calendar) {
+    this.registered.push(calendar.id);
+  }
+
+  onCalendarUnregistering(calendar) {
+    this.unregistering.push(calendar.id);
+  }
+
+  onCalendarDeleting(calendar) {
+    this.deleting.push(calendar.id);
+  }
+}
+
+add_test(function test_builtin_registration() {
+  function checkCalendarCount(net, rdonly, all) {
+    equal(cal.manager.networkCalendarCount, net);
+    equal(cal.manager.readOnlyCalendarCount, rdonly);
+    equal(cal.manager.calendarCount, all);
+  }
+
+  // Initially there should be no calendars.
+  checkCalendarCount(0, 0, 0);
+
+  // Create a local memory calendar, this shouldn't register any calendars.
+  let memory = cal.manager.createCalendar("memory", Services.io.newURI("moz-memory-calendar://"));
+  checkCalendarCount(0, 0, 0);
+
+  // Register an observer to test it.
+  let calmgrObserver = new CalendarManagerObserver();
+
+  let readOnly = false;
+  let calendarObserver = cal.createAdapter(Ci.calIObserver, {
+    onPropertyChanged(aCalendar, aName, aValue, aOldValue) {
+      equal(aCalendar.id, memory.id);
+      equal(aName, "readOnly");
+      readOnly = aValue;
+    },
+  });
+
+  memory.addObserver(calendarObserver);
+  cal.manager.addObserver(calmgrObserver);
+
+  // Register the calendar and check if its counted and observed.
+  cal.manager.registerCalendar(memory);
+  calmgrObserver.check({ registered: memory.id });
+  checkCalendarCount(0, 0, 1);
+
+  // The calendar should now have an id.
+  notEqual(memory.id, null);
+
+  // And be in the list of calendars.
+  equal(memory, cal.manager.getCalendarById(memory.id));
+  ok(cal.manager.getCalendars().some(x => x.id == memory.id));
+
+  // Make it readonly and check if the observer caught it.
+  memory.setProperty("readOnly", true);
+  equal(readOnly, true);
+
+  // Now unregister it.
+  cal.manager.unregisterCalendar(memory);
+  calmgrObserver.check({ unregistering: memory.id });
+  checkCalendarCount(0, 0, 0);
+
+  // The calendar shouldn't be in the list of ids.
+  equal(cal.manager.getCalendarById(memory.id), null);
+  ok(cal.manager.getCalendars().every(x => x.id != memory.id));
+
+  // And finally delete it.
+  cal.manager.removeCalendar(memory, Ci.calICalendarManager.REMOVE_NO_UNREGISTER);
+  calmgrObserver.check({ deleting: memory.id });
+  checkCalendarCount(0, 0, 0);
+
+  // Now remove the observer again.
+  cal.manager.removeObserver(calmgrObserver);
+  memory.removeObserver(calendarObserver);
+
+  // Check if removing it actually worked.
+  cal.manager.registerCalendar(memory);
+  cal.manager.removeCalendar(memory);
+  memory.setProperty("readOnly", false);
+  calmgrObserver.check({});
+  equal(readOnly, true);
+  checkCalendarCount(0, 0, 0);
+
+  // We are done now, start the next test.
+  run_next_test();
+});
+
+add_task(async function test_dynamic_registration() {
+  class CalendarProvider extends cal.provider.BaseClass {
+    QueryInterface = ChromeUtils.generateQI(["calICalendar"]);
+    type = "blm";
+
+    constructor() {
+      super();
+      this.initProviderBase();
+    }
+
+    getItems(itemFilter, count, rangeStart, rangeEnd, listener) {
+      return CalReadableStreamFactory.createEmptyReadableStream();
+    }
+  }
+
+  function checkCalendar(expectedCount = 1) {
+    let calendars = cal.manager.getCalendars();
+    equal(calendars.length, expectedCount);
+    let calendar = calendars[0];
+
+    if (expectedCount > 0) {
+      notEqual(calendar, null);
+    }
+    return calendar;
+  }
+
+  let calmgrObserver = new CalendarManagerObserver();
+  cal.manager.addObserver(calmgrObserver);
+  equal(cal.manager.calendarCount, 0);
+
+  // No provider registered.
+  let calendar = cal.manager.createCalendar("blm", Services.io.newURI("black-lives-matter://"));
+  equal(calendar, null);
+  ok(!cal.manager.hasCalendarProvider("blm"));
+
+  // Register dynamic provider.
+  cal.manager.registerCalendarProvider("blm", CalendarProvider);
+  calendar = cal.manager.createCalendar("blm", Services.io.newURI("black-lives-matter://"));
+  notEqual(calendar, null);
+  ok(calendar.wrappedJSObject instanceof CalendarProvider);
+  ok(cal.manager.hasCalendarProvider("blm"));
+
+  // Register a calendar using it.
+  cal.manager.registerCalendar(calendar);
+  calendar = checkCalendar();
+
+  let originalId = calendar.id;
+  calmgrObserver.check({ registered: originalId });
+
+  // Unregister the provider from under its feet.
+  cal.manager.unregisterCalendarProvider("blm");
+  calendar = checkCalendar();
+  calmgrObserver.check({ unregistering: originalId, registered: originalId });
+
+  equal(calendar.type, "blm");
+  equal(calendar.getProperty("force-disabled"), true);
+  equal(calendar.id, originalId);
+
+  // Re-register the provider should reactive it.
+  cal.manager.registerCalendarProvider("blm", CalendarProvider);
+  calendar = checkCalendar();
+  calmgrObserver.check({ unregistering: originalId, registered: originalId });
+
+  equal(calendar.type, "blm");
+  notEqual(calendar.getProperty("force-disabled"), true);
+  equal(calendar.id, originalId);
+
+  // Make sure calendar is loaded from prefs.
+  cal.manager.unregisterCalendarProvider("blm");
+  calmgrObserver.check({ unregistering: originalId, registered: originalId });
+
+  await new Promise(resolve => cal.manager.shutdown({ onResult: resolve }));
+  cal.manager.wrappedJSObject.mCache = null;
+  await new Promise(resolve => cal.manager.startup({ onResult: resolve }));
+  calmgrObserver.check({});
+
+  calendar = checkCalendar();
+  equal(calendar.type, "blm");
+  equal(calendar.getProperty("force-disabled"), true);
+  equal(calendar.id, originalId);
+
+  // Unregister the calendar for cleanup.
+  cal.manager.unregisterCalendar(calendar);
+  checkCalendar(0);
+  calmgrObserver.check({ unregistering: originalId });
+});
+
+add_test(function test_calobserver() {
+  function checkCounters(add, modify, del, alladd, allmodify, alldel) {
+    equal(calcounter.addItem, add);
+    equal(calcounter.modifyItem, modify);
+    equal(calcounter.deleteItem, del);
+    equal(allcounter.addItem, alladd === undefined ? add : alladd);
+    equal(allcounter.modifyItem, allmodify === undefined ? modify : allmodify);
+    equal(allcounter.deleteItem, alldel === undefined ? del : alldel);
+    resetCounters();
+  }
+  function resetCounters() {
+    calcounter = { addItem: 0, modifyItem: 0, deleteItem: 0 };
+    allcounter = { addItem: 0, modifyItem: 0, deleteItem: 0 };
+  }
+
+  // First of all we need a local calendar to work on and some variables
+  let memory = cal.manager.createCalendar("memory", Services.io.newURI("moz-memory-calendar://"));
+  let memory2 = cal.manager.createCalendar("memory", Services.io.newURI("moz-memory-calendar://"));
+  let calcounter, allcounter;
+
+  // These observers will end up counting calls which we will use later on
+  let calobs = cal.createAdapter(Ci.calIObserver, {
+    onAddItem: () => calcounter.addItem++,
+    onModifyItem: () => calcounter.modifyItem++,
+    onDeleteItem: () => calcounter.deleteItem++,
+  });
+  let allobs = cal.createAdapter(Ci.calIObserver, {
+    onAddItem: () => allcounter.addItem++,
+    onModifyItem: () => allcounter.modifyItem++,
+    onDeleteItem: () => allcounter.deleteItem++,
+  });
+
+  // Set up counters and observers
+  resetCounters();
+  cal.manager.registerCalendar(memory);
+  cal.manager.registerCalendar(memory2);
+  cal.manager.addCalendarObserver(allobs);
+  memory.addObserver(calobs);
+
+  // Add an item
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.startDate = cal.dtz.now();
+  item.endDate = cal.dtz.now();
+  memory.addItem(item);
+  checkCounters(1, 0, 0);
+
+  // Modify the item
+  let newItem = item.clone();
+  newItem.title = "title";
+  memory.modifyItem(newItem, item);
+  checkCounters(0, 1, 0);
+
+  // Delete the item
+  newItem.generation++; // circumvent generation checks for easier code
+  memory.deleteItem(newItem);
+  checkCounters(0, 0, 1);
+
+  // Now check the same for adding the item to a calendar only observed by the
+  // calendar manager. The calcounters should still be 0, but the calendar
+  // manager counter should have an item added, modified and deleted
+  memory2.addItem(item);
+  memory2.modifyItem(newItem, item);
+  memory2.deleteItem(newItem);
+  checkCounters(0, 0, 0, 1, 1, 1);
+
+  // Remove observers
+  memory.removeObserver(calobs);
+  cal.manager.removeCalendarObserver(allobs);
+
+  // Make sure removing it actually worked
+  memory.addItem(item);
+  memory.modifyItem(newItem, item);
+  memory.deleteItem(newItem);
+  checkCounters(0, 0, 0);
+
+  // We are done now, start the next test
+  run_next_test();
+});
+
+add_test(function test_removeModes() {
+  function checkCounts(modes, shouldDelete, expectCount, extraFlags = 0) {
+    if (cal.manager.calendarCount == baseCalendarCount) {
+      cal.manager.registerCalendar(memory);
+      equal(cal.manager.calendarCount, baseCalendarCount + 1);
+    }
+    deleteCalled = false;
+    removeModes = modes;
+
+    cal.manager.removeCalendar(memory, extraFlags);
+    equal(cal.manager.calendarCount, baseCalendarCount + expectCount);
+    equal(deleteCalled, shouldDelete);
+  }
+  function mockCalendar(memory) {
+    let oldGetProperty = memory.wrappedJSObject.getProperty;
+    memory.wrappedJSObject.getProperty = function (name) {
+      if (name == "capabilities.removeModes") {
+        return removeModes;
+      }
+      return oldGetProperty.apply(this, arguments);
+    };
+
+    let oldDeleteCalendar = memory.wrappedJSObject.deleteCalendar;
+    memory.wrappedJSObject.deleteCalendar = function (calendar, listener) {
+      deleteCalled = true;
+      return oldDeleteCalendar.apply(this, arguments);
+    };
+  }
+
+  // For better readability
+  const SHOULD_DELETE = true,
+    SHOULD_NOT_DELETE = false;
+
+  let memory = cal.manager.createCalendar("memory", Services.io.newURI("moz-memory-calendar://"));
+  let baseCalendarCount = cal.manager.calendarCount;
+  let removeModes = null;
+  let deleteCalled = false;
+
+  mockCalendar(memory);
+
+  checkCounts([], SHOULD_NOT_DELETE, 1);
+  checkCounts(["unsubscribe"], SHOULD_NOT_DELETE, 0);
+  checkCounts(["unsubscribe", "delete"], SHOULD_DELETE, 0);
+  checkCounts(
+    ["unsubscribe", "delete"],
+    SHOULD_NOT_DELETE,
+    0,
+    Ci.calICalendarManager.REMOVE_NO_DELETE
+  );
+  checkCounts(["delete"], SHOULD_DELETE, 0);
+
+  run_next_test();
+});
+
+add_test(function test_calprefs() {
+  let prop;
+  let memory = cal.manager.createCalendar("memory", Services.io.newURI("moz-memory-calendar://"));
+  cal.manager.registerCalendar(memory);
+  let memid = memory.id;
+
+  // First set a few values, one of each relevant type
+  memory.setProperty("stringpref", "abc");
+  memory.setProperty("boolpref", true);
+  memory.setProperty("intpref", 123);
+  memory.setProperty("bigintpref", 1394548721296);
+  memory.setProperty("floatpref", 0.5);
+
+  // Before checking the value, reinitialize the memory calendar with the
+  // same id to make sure the pref value isn't just cached
+  memory = cal.manager.createCalendar("memory", Services.io.newURI("moz-memory-calendar://"));
+  memory.id = memid;
+
+  // First test the standard types
+  prop = memory.getProperty("stringpref");
+  equal(typeof prop, "string");
+  equal(prop, "abc");
+
+  prop = memory.getProperty("boolpref");
+  equal(typeof prop, "boolean");
+  equal(prop, true);
+
+  prop = memory.getProperty("intpref");
+  equal(typeof prop, "number");
+  equal(prop, 123);
+
+  // These two are a special case test for bug 979262
+  prop = memory.getProperty("bigintpref");
+  equal(typeof prop, "number");
+  equal(prop, 1394548721296);
+
+  prop = memory.getProperty("floatpref");
+  equal(typeof prop, "number");
+  equal(prop, 0.5);
+
+  // Check if changing pref types works. We need to reset the calendar again
+  // because retrieving the value just cached it again.
+  memory = cal.manager.createCalendar("memory", Services.io.newURI("moz-memory-calendar://"));
+  memory.id = memid;
+
+  cal.manager.setCalendarPref_(memory, "boolpref", "kinda true");
+  prop = memory.getProperty("boolpref");
+  equal(typeof prop, "string");
+  equal(prop, "kinda true");
+
+  // Check if unsetting a pref works
+  memory.setProperty("intpref", null);
+  memory = cal.manager.createCalendar("memory", Services.io.newURI("moz-memory-calendar://"));
+  memory.id = memid;
+  prop = memory.getProperty("intpref");
+  ok(prop === null);
+
+  // We are done now, start the next test
+  run_next_test();
+});
diff --git a/comm/calendar/test/unit/test_calreadablestreamfactory.js b/comm/calendar/test/unit/test_calreadablestreamfactory.js
new file mode 100644
index 0000000000..9da71e47ef
--- /dev/null
+++ b/comm/calendar/test/unit/test_calreadablestreamfactory.js
@@ -0,0 +1,195 @@
+/* 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/. */
+
+/**
+ * Tests for the ReadableStreams generated by CalReadableStreamFactory.
+ */
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+var { CalReadableStreamFactory } = ChromeUtils.import(
+  "resource:///modules/CalReadableStreamFactory.jsm"
+);
+
+/**
+ * @type {object} BoundedReadableStreamTestSpec
+ * @property {number}   maxTotalItems
+ * @property {number}   maxQueuedItems
+ * @property {number}   actualTotalItems
+ * @property {number}   actualChunkSize
+ * @property {Function} onChunk
+ */
+
+/**
+ * Common test for the BoundedReadableStream.
+ *
+ * @param {BoundedReadableStreamTestSpec} spec
+ */
+async function doBoundedReadableStreamTest({
+  maxTotalItems,
+  maxQueuedItems,
+  actualTotalItems,
+  actualChunkSize,
+  onChunk,
+}) {
+  let totalChunks = Math.ceil(actualTotalItems / actualChunkSize);
+  let stream = CalReadableStreamFactory.createBoundedReadableStream(maxTotalItems, maxQueuedItems, {
+    start(controller) {
+      let i = 0;
+      for (i; i < totalChunks; i++) {
+        controller.enqueue(
+          Array(actualChunkSize)
+            .fill(null)
+            .map(() => new CalEvent())
+        );
+      }
+      info(
+        `Enqueued ${
+          i * actualChunkSize
+        } items across ${i} chunks at a rate of ${actualChunkSize} items per chunk`
+      );
+    },
+  });
+
+  for await (let chunk of cal.iterate.streamValues(stream)) {
+    Assert.ok(Array.isArray(chunk), "chunk received is an array");
+    Assert.ok(
+      chunk.every(item => item instanceof CalEvent),
+      "all chunk elements are CalEvent instances"
+    );
+    onChunk(chunk);
+  }
+}
+
+/**
+ * Tests the BoundedReadableStream works as expected when the total items enqueued
+ * and the chunk size match the limits set.
+ */
+add_task(async function testBoundedReadableStreamWorksWithinLimits() {
+  let maxTotalItems = 35;
+  let maxQueuedItems = 5;
+  let totalChunks = 35 / 5;
+
+  let chunksRead = 0;
+  await doBoundedReadableStreamTest({
+    maxTotalItems,
+    maxQueuedItems,
+    actualTotalItems: maxTotalItems,
+    actualChunkSize: maxQueuedItems,
+    onChunk(chunk) {
+      Assert.equal(chunk.length, maxQueuedItems, `chunk has ${maxQueuedItems} items`);
+      chunksRead++;
+    },
+  });
+  Assert.equal(chunksRead, totalChunks, `received ${totalChunks} chunks from stream`);
+});
+
+/**
+ * Tests that the stream automatically closes when maxTotalItemsReached is true
+ * even if there are more items to come.
+ */
+add_task(async function testBoundedReadableStreamClosesIfMaxTotalItemsReached() {
+  let maxTotalItems = 35;
+  let maxQueuedItems = 5;
+  let items = [];
+
+  await doBoundedReadableStreamTest({
+    maxTotalItems,
+    maxQueuedItems,
+    actualTotalItems: 50,
+    actualChunkSize: 7,
+    onChunk(chunk) {
+      items = items.concat(chunk);
+    },
+  });
+  Assert.equal(items.length, maxTotalItems, `received ${maxTotalItems} items from stream`);
+});
+
+/**
+ * Test that chunks enqueued with smaller than the maxQueueSize value are held
+ * until the threshold is reached.
+ */
+add_task(async function testBoundedReadableStreamBuffersChunks() {
+  let maxTotalItems = 35;
+  let maxQueuedItems = 5;
+  let totalChunks = 35 / 5;
+
+  let chunksRead = 0;
+  await doBoundedReadableStreamTest({
+    maxTotalItems,
+    maxQueuedItems,
+    actualTotalItems: 35,
+    actualChunkSize: 1,
+    onChunk(chunk) {
+      Assert.equal(chunk.length, maxQueuedItems, `chunk has ${maxQueuedItems} items`);
+      chunksRead++;
+    },
+  });
+  Assert.equal(chunksRead, totalChunks, `received ${totalChunks} chunks from stream`);
+});
+
+/**
+ * Test the CombinedReadbleStream streams from all of its streams.
+ */
+add_task(async function testCombinedReadableStreamStreamsAll() {
+  let mkStream = () =>
+    CalReadableStreamFactory.createReadableStream({
+      start(controller) {
+        for (let i = 0; i < 5; i++) {
+          controller.enqueue(new CalEvent());
+        }
+        controller.close();
+      },
+    });
+
+  let stream = CalReadableStreamFactory.createCombinedReadableStream([
+    mkStream(),
+    mkStream(),
+    mkStream(),
+  ]);
+
+  let items = [];
+  for await (let value of cal.iterate.streamValues(stream)) {
+    Assert.ok(value instanceof CalEvent, "value read from stream is CalEvent instance");
+    items.push(value);
+  }
+  Assert.equal(items.length, 15, "read a total of 15 items from the stream");
+});
+
+/**
+ * Test the MappedReadableStream applies the MapStreamFunction to each value
+ * read from the stream.
+ */
+add_task(async function testMappedReadableStream() {
+  let stream = CalReadableStreamFactory.createMappedReadableStream(
+    CalReadableStreamFactory.createReadableStream({
+      start(controller) {
+        for (let i = 0; i < 10; i++) {
+          controller.enqueue(1);
+        }
+        controller.close();
+      },
+    }),
+    value => value * 0
+  );
+
+  let values = [];
+  for await (let value of cal.iterate.streamValues(stream)) {
+    Assert.equal(value, 0, "read value inverted to 0");
+    values.push(value);
+  }
+  Assert.equal(values.length, 10, "all 10 values were transformed");
+});
+
+/**
+ * Test the EmptyReadableStream is already closed.
+ */
+add_task(async function testEmptyReadableStream() {
+  let stream = CalReadableStreamFactory.createEmptyReadableStream();
+  let values = [];
+  for await (let value of cal.iterate.streamValues(stream)) {
+    values.push(value);
+  }
+  Assert.equal(values.length, 0, "no values were read from the empty stream");
+});
diff --git a/comm/calendar/test/unit/test_data_bags.js b/comm/calendar/test/unit/test_data_bags.js
new file mode 100644
index 0000000000..dd1f2a6abd
--- /dev/null
+++ b/comm/calendar/test/unit/test_data_bags.js
@@ -0,0 +1,151 @@
+/* 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 run_test() {
+  test_listener_set();
+  test_observer_set();
+  test_operation_group();
+}
+
+function test_listener_set() {
+  let set = new cal.data.ListenerSet(Ci.calIOperationListener);
+  let listener1Id = null;
+  let listener2Id = null;
+
+  let listener1 = cal.createAdapter("calIOperationListener", {
+    onOperationComplete(aCalendar, aStatus, aOpType, aId, aDetail) {
+      listener1Id = aId;
+    },
+  });
+  let listener2 = cal.createAdapter("calIOperationListener", {
+    onOperationComplete(aCalendar, aStatus, aOpType, aId, aDetail) {
+      listener2Id = aId;
+    },
+  });
+
+  set.add(listener1);
+  set.add(listener2);
+  set.notify("onOperationComplete", [null, null, null, "test", null]);
+  equal(listener1Id, "test");
+  equal(listener2Id, "test");
+
+  set.delete(listener2);
+  listener1Id = listener2Id = null;
+  set.notify("onOperationComplete", [null, null, null, "test2", null]);
+  equal(listener1Id, "test2");
+  strictEqual(listener2Id, null);
+
+  // Re-adding the listener may lead to an endless loop if the notify
+  // function uses a live list of observers.
+  let called = 0;
+  let listener3 = cal.createAdapter("calIOperationListener", {
+    onOperationComplete(aCalendar, aStatus, aOpType, aId, aDetail) {
+      set.delete(listener3);
+      if (called == 0) {
+        set.add(listener3);
+      }
+      called++;
+    },
+  });
+
+  set.add(listener3);
+  set.notify("onOperationComplete", [null, null, null, "test3", null]);
+  equal(called, 1);
+}
+
+function test_observer_set() {
+  let set = new cal.data.ObserverSet(Ci.calIObserver);
+  let listenerCountBegin1 = 0;
+  let listenerCountBegin2 = 0;
+  let listenerCountEnd1 = 0;
+  let listenerCountEnd2 = 0;
+
+  let listener1 = cal.createAdapter("calIObserver", {
+    onStartBatch() {
+      listenerCountBegin1++;
+    },
+    onEndBatch() {
+      listenerCountEnd1++;
+    },
+  });
+  let listener2 = cal.createAdapter("calIObserver", {
+    onStartBatch() {
+      listenerCountBegin2++;
+    },
+    onEndBatch() {
+      listenerCountEnd2++;
+    },
+  });
+
+  set.add(listener1);
+  equal(listenerCountBegin1, 0);
+  equal(listenerCountEnd1, 0);
+  equal(set.batchCount, 0);
+
+  set.notify("onStartBatch");
+  equal(listenerCountBegin1, 1);
+  equal(listenerCountEnd1, 0);
+  equal(set.batchCount, 1);
+
+  set.add(listener2);
+  equal(listenerCountBegin1, 1);
+  equal(listenerCountEnd1, 0);
+  equal(listenerCountBegin2, 1);
+  equal(listenerCountEnd2, 0);
+  equal(set.batchCount, 1);
+
+  set.add(listener1);
+  equal(listenerCountBegin1, 1);
+  equal(listenerCountEnd1, 0);
+  equal(listenerCountBegin2, 1);
+  equal(listenerCountEnd2, 0);
+  equal(set.batchCount, 1);
+
+  set.notify("onEndBatch");
+  equal(listenerCountBegin1, 1);
+  equal(listenerCountEnd1, 1);
+  equal(listenerCountBegin2, 1);
+  equal(listenerCountEnd2, 1);
+  equal(set.batchCount, 0);
+}
+
+function test_operation_group() {
+  let calledCancel = false;
+  let calledOperationCancel = null;
+  let group = new cal.data.OperationGroup();
+  ok(group.id.endsWith("-0"));
+  ok(group.isPending);
+  equal(group.status, Cr.NS_OK);
+  ok(group.isEmpty);
+
+  let operation = {
+    id: 123,
+    isPending: true,
+    cancel: status => {
+      calledOperationCancel = status;
+    },
+  };
+
+  group.add(operation);
+  ok(!group.isEmpty);
+
+  group.notifyCompleted(Cr.NS_ERROR_FAILURE);
+  ok(!group.isPending);
+  equal(group.status, Cr.NS_ERROR_FAILURE);
+  strictEqual(calledOperationCancel, null);
+
+  group.remove(operation);
+  ok(group.isEmpty);
+
+  group = new cal.data.OperationGroup(() => {
+    calledCancel = true;
+  });
+  ok(group.id.endsWith("-1"));
+  group.add(operation);
+
+  group.cancel();
+  equal(group.status, Ci.calIErrors.OPERATION_CANCELLED);
+  equal(calledOperationCancel, Ci.calIErrors.OPERATION_CANCELLED);
+  ok(calledCancel);
+}
diff --git a/comm/calendar/test/unit/test_datetime.js b/comm/calendar/test/unit/test_datetime.js
new file mode 100644
index 0000000000..a754e570a8
--- /dev/null
+++ b/comm/calendar/test/unit/test_datetime.js
@@ -0,0 +1,99 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+function run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  function getMozTimezone(tzid) {
+    return cal.timezoneService.getTimezone(tzid);
+  }
+
+  let date = cal.createDateTime();
+  date.resetTo(2005, 10, 13, 10, 0, 0, getMozTimezone("/mozilla.org/20050126_1/America/Bogota"));
+
+  equal(date.hour, 10);
+  equal(date.icalString, "20051113T100000");
+
+  let date_floating = date.getInTimezone(cal.dtz.floating);
+  equal(date_floating.hour, 10);
+
+  let date_utc = date.getInTimezone(cal.dtz.UTC);
+  equal(date_utc.hour, 15);
+  equal(date_utc.icalString, "20051113T150000Z");
+
+  date.hour = 25;
+  equal(date.hour, 1);
+  equal(date.day, 14);
+
+  // Test nativeTime on dates
+  // setting .isDate to be true on a date should not change its nativeTime
+  // bug 315954,
+  date.hour = 0;
+  let date_allday = date.clone();
+  date_allday.isDate = true;
+  equal(date.nativeTime, date_allday.nativeTime);
+
+  // Daylight savings test
+  date.resetTo(2006, 2, 26, 1, 0, 0, getMozTimezone("/mozilla.org/20050126_1/Europe/Amsterdam"));
+
+  equal(date.weekday, 0);
+  equal(date.timezoneOffset, 1 * 3600);
+
+  date.day += 1;
+  equal(date.timezoneOffset, 2 * 3600);
+
+  // Bug 398724 - Problems with floating all-day items
+  let event = new CalEvent(
+    "BEGIN:VEVENT\nUID:45674d53-229f-48c6-9f3b-f2b601e7ae4d\nSUMMARY:New Event\nDTSTART;VALUE=DATE:20071003\nDTEND;VALUE=DATE:20071004\nEND:VEVENT"
+  );
+  ok(event.startDate.timezone.isFloating);
+  ok(event.endDate.timezone.isFloating);
+
+  // Bug 392853 - Same times, different timezones, but subtractDate says times are PT0S apart
+  const zeroLength = cal.createDuration();
+  const a = cal.dtz.jsDateToDateTime(new Date());
+  a.timezone = getMozTimezone("/mozilla.org/20071231_1/Europe/Berlin");
+
+  let b = a.clone();
+  b.timezone = getMozTimezone("/mozilla.org/20071231_1/America/New_York");
+
+  let duration = a.subtractDate(b);
+  notEqual(duration.compare(zeroLength), 0);
+  notEqual(a.compare(b), 0);
+
+  // Should lead to zero length duration
+  b = a.getInTimezone(getMozTimezone("/mozilla.org/20071231_1/America/New_York"));
+  duration = a.subtractDate(b);
+  equal(duration.compare(zeroLength), 0);
+  equal(a.compare(b), 0);
+
+  // Check that we can get the same timezone with several aliases
+  equal(getMozTimezone("/mozilla.org/xyz/Asia/Calcutta").tzid, "Asia/Calcutta");
+  equal(getMozTimezone("Asia/Calcutta").tzid, "Asia/Calcutta");
+  equal(getMozTimezone("Asia/Kolkata").tzid, "Asia/Kolkata");
+
+  // A newly created date should be in UTC, as should its clone
+  let utc = cal.createDateTime();
+  equal(utc.timezone.tzid, "UTC");
+  equal(utc.clone().timezone.tzid, "UTC");
+  equal(utc.timezoneOffset, 0);
+
+  // Bug 794477 - setting jsdate across compartments needs to work
+  let someDate = new Date();
+  let createdDate = cal.dtz.jsDateToDateTime(someDate).getInTimezone(cal.dtz.defaultTimezone);
+  someDate.setMilliseconds(0);
+  equal(someDate.getTime(), cal.dtz.dateTimeToJsDate(createdDate).getTime());
+
+  // Comparing a date-time with a date of the same day should be 0
+  equal(cal.createDateTime("20120101T120000").compare(cal.createDateTime("20120101")), 0);
+  equal(cal.createDateTime("20120101").compare(cal.createDateTime("20120101T120000")), 0);
+}
diff --git a/comm/calendar/test/unit/test_datetime_before_1970.js b/comm/calendar/test/unit/test_datetime_before_1970.js
new file mode 100644
index 0000000000..a5e5dd0054
--- /dev/null
+++ b/comm/calendar/test/unit/test_datetime_before_1970.js
@@ -0,0 +1,31 @@
+/* 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 run_test() {
+  // Bug 769938 - dates before 1970 are not handled correctly
+  // due to signed vs. unsigned mismatch in PRTime in xpconnect
+
+  let dateTime1950 = cal.createDateTime();
+  dateTime1950.year = 1950;
+  equal(dateTime1950.year, 1950);
+
+  let dateTime1955 = cal.dtz.jsDateToDateTime(new Date(Date.UTC(1955, 6, 15)));
+  equal(dateTime1955.year, 1955);
+
+  let dateTime1965 = cal.createDateTime();
+  dateTime1965.nativeTime = -150000000000000;
+  equal(dateTime1965.year, 1965);
+  equal(dateTime1965.nativeTime, -150000000000000);
+
+  let dateTime1990 = cal.createDateTime();
+  dateTime1990.year = 1990;
+
+  let dateTime2050 = cal.createDateTime();
+  dateTime2050.year = 2050;
+
+  ok(dateTime1950.nativeTime < dateTime1955.nativeTime);
+  ok(dateTime1955.nativeTime < dateTime1965.nativeTime);
+  ok(dateTime1965.nativeTime < dateTime1990.nativeTime);
+  ok(dateTime1990.nativeTime < dateTime2050.nativeTime);
+}
diff --git a/comm/calendar/test/unit/test_datetimeformatter.js b/comm/calendar/test/unit/test_datetimeformatter.js
new file mode 100644
index 0000000000..d297b25d0b
--- /dev/null
+++ b/comm/calendar/test/unit/test_datetimeformatter.js
@@ -0,0 +1,604 @@
+/* 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 { formatter } = cal.dtz;
+
+const { CalTimezone } = ChromeUtils.import("resource:///modules/CalTimezone.jsm");
+const { ICAL } = ChromeUtils.import("resource:///modules/calendar/Ical.jsm");
+
+function run_test() {
+  do_calendar_startup(run_next_test);
+}
+
+// This test assumes the timezone of your system is not set to Pacific/Fakaofo or equivalent.
+
+// Time format is platform dependent, so we use alternative result sets here in 'expected'.
+// The first two meet configurations running for automated tests,
+// the first one is for Windows, the second one for Linux and Mac, unless otherwise noted.
+// If you get a failure for this test, add your pattern here.
+
+add_task(async function formatDate_test() {
+  let data = [
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "Pacific/Fakaofo",
+        dateformat: 0, // long
+      },
+      expected: ["Saturday, April 01, 2017", "Saturday, April 1, 2017"],
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "Pacific/Fakaofo",
+        dateformat: 1, // short
+      },
+      expected: ["4/1/2017", "4/1/17"],
+    },
+  ];
+
+  let dateformat = Services.prefs.getIntPref("calendar.date.format", 0);
+  let tzlocal = Services.prefs.getStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+  Services.prefs.setStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+
+  let i = 0;
+  for (let test of data) {
+    i++;
+    Services.prefs.setIntPref("calendar.date.format", test.input.dateformat);
+    let zone =
+      test.input.timezone == "floating"
+        ? cal.dtz.floating
+        : cal.timezoneService.getTimezone(test.input.timezone);
+    let date = cal.createDateTime(test.input.datetime).getInTimezone(zone);
+
+    let formatted = formatter.formatDate(date);
+    ok(
+      test.expected.includes(formatted),
+      "(test #" + i + ": result '" + formatted + "', expected '" + test.expected + "')"
+    );
+  }
+  // let's reset the preferences
+  Services.prefs.setStringPref("calendar.timezone.local", tzlocal);
+  Services.prefs.setIntPref("calendar.date.format", dateformat);
+});
+
+add_task(async function formatDateShort_test() {
+  let data = [
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "Pacific/Fakaofo",
+      },
+      expected: ["4/1/2017", "4/1/17"],
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "Pacific/Kiritimati",
+      },
+      expected: ["4/1/2017", "4/1/17"],
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "UTC",
+      },
+      expected: ["4/1/2017", "4/1/17"],
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "floating",
+      },
+      expected: ["4/1/2017", "4/1/17"],
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "Pacific/Fakaofo",
+      },
+      expected: ["4/1/2017", "4/1/17"],
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "Pacific/Kiritimati",
+      },
+      expected: ["4/1/2017", "4/1/17"],
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "UTC",
+      },
+      expected: ["4/1/2017", "4/1/17"],
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "floating",
+      },
+      expected: ["4/1/2017", "4/1/17"],
+    },
+  ];
+
+  let dateformat = Services.prefs.getIntPref("calendar.date.format", 0);
+  let tzlocal = Services.prefs.getStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+  Services.prefs.setStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+  // we make sure to have set long format
+  Services.prefs.setIntPref("calendar.date.format", 0);
+
+  let i = 0;
+  for (let test of data) {
+    i++;
+
+    let zone =
+      test.input.timezone == "floating"
+        ? cal.dtz.floating
+        : cal.timezoneService.getTimezone(test.input.timezone);
+    let date = cal.createDateTime(test.input.datetime).getInTimezone(zone);
+
+    let formatted = formatter.formatDateShort(date);
+    ok(
+      test.expected.includes(formatted),
+      "(test #" + i + ": result '" + formatted + "', expected '" + test.expected + "')"
+    );
+  }
+  // let's reset the preferences
+  Services.prefs.setStringPref("calendar.timezone.local", tzlocal);
+  Services.prefs.setIntPref("calendar.date.format", dateformat);
+});
+
+add_task(async function formatDateLong_test() {
+  let data = [
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "Pacific/Fakaofo",
+      },
+      expected: ["Saturday, April 01, 2017", "Saturday, April 1, 2017"],
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "Pacific/Kiritimati",
+      },
+      expected: ["Saturday, April 01, 2017", "Saturday, April 1, 2017"],
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "UTC",
+      },
+      expected: ["Saturday, April 01, 2017", "Saturday, April 1, 2017"],
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "floating",
+      },
+      expected: ["Saturday, April 01, 2017", "Saturday, April 1, 2017"],
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "Pacific/Fakaofo",
+      },
+      expected: ["Saturday, April 01, 2017", "Saturday, April 1, 2017"],
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "Pacific/Kiritimati",
+      },
+      expected: ["Saturday, April 01, 2017", "Saturday, April 1, 2017"],
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "UTC",
+      },
+      expected: ["Saturday, April 01, 2017", "Saturday, April 1, 2017"],
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "floating",
+      },
+      expected: ["Saturday, April 01, 2017", "Saturday, April 1, 2017"],
+    },
+  ];
+
+  let dateformat = Services.prefs.getIntPref("calendar.date.format", 0);
+  let tzlocal = Services.prefs.getStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+  Services.prefs.setStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+  // we make sure to have set short format
+  Services.prefs.setIntPref("calendar.date.format", 1);
+
+  let i = 0;
+  for (let test of data) {
+    i++;
+
+    let zone =
+      test.input.timezone == "floating"
+        ? cal.dtz.floating
+        : cal.timezoneService.getTimezone(test.input.timezone);
+    let date = cal.createDateTime(test.input.datetime).getInTimezone(zone);
+
+    let formatted = formatter.formatDateLong(date);
+    ok(
+      test.expected.includes(formatted),
+      "(test #" + i + ": result '" + formatted + "', expected '" + test.expected + "')"
+    );
+  }
+  // let's reset the preferences
+  Services.prefs.setStringPref("calendar.timezone.local", tzlocal);
+  Services.prefs.setIntPref("calendar.date.format", dateformat);
+});
+
+add_task(async function formatDateWithoutYear_test() {
+  let data = [
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "Pacific/Fakaofo",
+      },
+      expected: "Apr 1",
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "Pacific/Kiritimati",
+      },
+      expected: "Apr 1",
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "UTC",
+      },
+      expected: "Apr 1",
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "floating",
+      },
+      expected: "Apr 1",
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "Pacific/Fakaofo",
+      },
+      expected: "Apr 1",
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "Pacific/Kiritimati",
+      },
+      expected: "Apr 1",
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "UTC",
+      },
+      expected: "Apr 1",
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "floating",
+      },
+      expected: "Apr 1",
+    },
+  ];
+
+  let dateformat = Services.prefs.getIntPref("calendar.date.format", 0);
+  let tzlocal = Services.prefs.getStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+  Services.prefs.setStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+  // we make sure to have set short format
+  Services.prefs.setIntPref("calendar.date.format", 1);
+
+  let i = 0;
+  for (let test of data) {
+    i++;
+
+    let zone =
+      test.input.timezone == "floating"
+        ? cal.dtz.floating
+        : cal.timezoneService.getTimezone(test.input.timezone);
+    let date = cal.createDateTime(test.input.datetime).getInTimezone(zone);
+
+    equal(formatter.formatDateWithoutYear(date), test.expected, "(test #" + i + ")");
+  }
+  // let's reset the preferences
+  Services.prefs.setStringPref("calendar.timezone.local", tzlocal);
+  Services.prefs.setIntPref("calendar.date.format", dateformat);
+});
+
+add_task(async function formatDateLongWithoutYear_test() {
+  let data = [
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "Pacific/Fakaofo",
+      },
+      expected: "Saturday, April 1",
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "Pacific/Kiritimati",
+      },
+      expected: "Saturday, April 1",
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "UTC",
+      },
+      expected: "Saturday, April 1",
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "floating",
+      },
+      expected: "Saturday, April 1",
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "Pacific/Fakaofo",
+      },
+      expected: "Saturday, April 1",
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "Pacific/Kiritimati",
+      },
+      expected: "Saturday, April 1",
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "UTC",
+      },
+      expected: "Saturday, April 1",
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "floating",
+      },
+      expected: "Saturday, April 1",
+    },
+  ];
+
+  let dateformat = Services.prefs.getIntPref("calendar.date.format", 0);
+  let tzlocal = Services.prefs.getStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+  Services.prefs.setStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+  // we make sure to have set short format
+  Services.prefs.setIntPref("calendar.date.format", 1);
+
+  let i = 0;
+  for (let test of data) {
+    i++;
+
+    let zone =
+      test.input.timezone == "floating"
+        ? cal.dtz.floating
+        : cal.timezoneService.getTimezone(test.input.timezone);
+    let date = cal.createDateTime(test.input.datetime).getInTimezone(zone);
+
+    equal(formatter.formatDateLongWithoutYear(date), test.expected, "(test #" + i + ")");
+  }
+  // let's reset the preferences
+  Services.prefs.setStringPref("calendar.timezone.local", tzlocal);
+  Services.prefs.setIntPref("calendar.date.format", dateformat);
+});
+
+add_task(async function formatTime_test() {
+  let data = [
+    {
+      input: {
+        datetime: "20170401T090000",
+        timezone: "Pacific/Fakaofo",
+      },
+      expected: ["9:00 AM", "09:00"], // Windows+Mac, Linux.
+    },
+    {
+      input: {
+        datetime: "20170401T090000",
+        timezone: "Pacific/Kiritimati",
+      },
+      expected: ["9:00 AM", "09:00"],
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "UTC",
+      },
+      expected: ["6:00 PM", "18:00"],
+    },
+    {
+      input: {
+        datetime: "20170401T180000",
+        timezone: "floating",
+      },
+      expected: ["6:00 PM", "18:00"],
+    },
+    {
+      input: {
+        datetime: "20170401",
+        timezone: "Pacific/Fakaofo",
+      },
+      expected: "All Day",
+    },
+  ];
+
+  let tzlocal = Services.prefs.getStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+  Services.prefs.setStringPref("calendar.timezone.local", "Pacific/Fakaofo");
+
+  let i = 0;
+  for (let test of data) {
+    i++;
+
+    let zone =
+      test.input.timezone == "floating"
+        ? cal.dtz.floating
+        : cal.timezoneService.getTimezone(test.input.timezone);
+    let date = cal.createDateTime(test.input.datetime).getInTimezone(zone);
+
+    let formatted = formatter.formatTime(date);
+    ok(
+      test.expected.includes(formatted),
+      "(test #" + i + ": result '" + formatted + "', expected '" + test.expected + "')"
+    );
+  }
+  // let's reset the preferences
+  Services.prefs.setStringPref("calendar.timezone.local", tzlocal);
+});
+
+add_task(function formatTime_test_with_arbitrary_timezone() {
+  // Create a timezone with an arbitrary offset and a time zone ID we can be
+  // reasonably sure Gecko won't recognize so we can be sure that we aren't
+  // relying on the time zone ID to be valid.
+  const tzdef =
+    "BEGIN:VTIMEZONE\n" +
+    "TZID:Nowhere/Middle\n" +
+    "BEGIN:STANDARD\n" +
+    "DTSTART:16010101T000000\n" +
+    "TZOFFSETFROM:-0741\n" +
+    "TZOFFSETTO:-0741\n" +
+    "END:STANDARD\n" +
+    "END:VTIMEZONE";
+
+  const timezone = new CalTimezone(
+    ICAL.Timezone.fromData({
+      tzid: "Nowhere/Middle",
+      component: tzdef,
+    })
+  );
+
+  const expected = ["6:19 AM", "06:19"];
+
+  const dateTime = cal.createDateTime("20220916T140000Z").getInTimezone(timezone);
+  const formatted = formatter.formatTime(dateTime);
+
+  ok(expected.includes(formatted), `expected '${expected}', actual result ${formatted}`);
+});
+
+add_task(async function formatInterval_test() {
+  let data = [
+    //1: task-without-dates
+    {
+      input: {},
+      expected: "no start or due date",
+    },
+    //2: task-without-due-date
+    {
+      input: { start: "20220916T140000Z" },
+      expected: [
+        "start date Friday, September 16, 2022 2:00 PM",
+        "start date Friday, September 16, 2022 14:00",
+      ],
+    },
+    //3: task-without-start-date
+    {
+      input: { end: "20220916T140000Z" },
+      expected: [
+        "due date Friday, September 16, 2022 2:00 PM",
+        "due date Friday, September 16, 2022 14:00",
+      ],
+    },
+    //4: all-day
+    {
+      input: {
+        start: "20220916T140000Z",
+        end: "20220916T140000Z",
+        allDay: true,
+      },
+      expected: "Friday, September 16, 2022",
+    },
+    //5: all-day-between-years
+    {
+      input: {
+        start: "20220916T140000Z",
+        end: "20230916T140000Z",
+        allDay: true,
+      },
+      expected: "September 16, 2022 – September 16, 2023",
+    },
+    //6: all-day-in-month
+    {
+      input: {
+        start: "20220916T140000Z",
+        end: "20220920T140000Z",
+        allDay: true,
+      },
+      expected: "September 16 – 20, 2022",
+    },
+    //7: all-day-between-months
+    {
+      input: {
+        start: "20220916T140000Z",
+        end: "20221020T140000Z",
+        allDay: true,
+      },
+      expected: "September 16 – October 20, 2022",
+    },
+    //8: same-date-time
+    {
+      input: {
+        start: "20220916T140000Z",
+        end: "20220916T140000Z",
+      },
+      expected: ["Friday, September 16, 2022 2:00 PM", "Friday, September 16, 2022 14:00"],
+    },
+    //9: same-day
+    {
+      input: {
+        start: "20220916T140000Z",
+        end: "20220916T160000Z",
+      },
+      expected: [
+        "Friday, September 16, 2022 2:00 PM – 4:00 PM",
+        "Friday, September 16, 2022 14:00 – 16:00",
+      ],
+    },
+    //10: several-days
+    {
+      input: {
+        start: "20220916T140000Z",
+        end: "20220920T160000Z",
+      },
+      expected: [
+        "Friday, September 16, 2022 2:00 PM – Tuesday, September 20, 2022 4:00 PM",
+        "Friday, September 16, 2022 14:00 – Tuesday, September 20, 2022 16:00",
+      ],
+    },
+  ];
+
+  let i = 0;
+  for (let test of data) {
+    i++;
+    let startDate = test.input.start ? cal.createDateTime(test.input.start) : null;
+    let endDate = test.input.end ? cal.createDateTime(test.input.end) : null;
+
+    if (test.input.allDay) {
+      startDate.isDate = true;
+    }
+
+    let formatted = formatter.formatInterval(startDate, endDate);
+    ok(
+      test.expected.includes(formatted),
+      "(test #" + i + ": result '" + formatted + "', expected '" + test.expected + "')"
+    );
+  }
+});
diff --git a/comm/calendar/test/unit/test_deleted_items.js b/comm/calendar/test/unit/test_deleted_items.js
new file mode 100644
index 0000000000..d68c927dae
--- /dev/null
+++ b/comm/calendar/test/unit/test_deleted_items.js
@@ -0,0 +1,106 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+add_setup(function () {
+  // The deleted items service is started automatically by the start-up
+  // procedure, but that doesn't happen in XPCShell tests. Add an observer
+  // ourselves to simulate the behaviour.
+  let delmgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(Ci.calIDeletedItems);
+  Services.obs.addObserver(delmgr, "profile-after-change");
+
+  do_calendar_startup(run_next_test);
+});
+
+function check_delmgr_call(aFunc) {
+  let delmgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(Ci.calIDeletedItems);
+
+  return new Promise((resolve, reject) => {
+    delmgr.wrappedJSObject.completedNotifier.handleCompletion = aReason => {
+      if (aReason == Ci.mozIStorageStatementCallback.REASON_FINISHED) {
+        resolve();
+      } else {
+        reject(aReason);
+      }
+    };
+    aFunc();
+  });
+}
+
+add_task(async function test_deleted_items() {
+  let delmgr = Cc["@mozilla.org/calendar/deleted-items-manager;1"].getService(Ci.calIDeletedItems);
+
+  // No items have been deleted, retrieving one should return null.
+  equal(delmgr.getDeletedDate("random"), null);
+  equal(delmgr.getDeletedDate("random", "random"), null);
+
+  // Make sure the cache is initially flushed and that this doesn't throw an
+  // error.
+  await check_delmgr_call(() => delmgr.flush());
+
+  let memory = cal.manager.createCalendar("memory", Services.io.newURI("moz-storage-calendar://"));
+  cal.manager.registerCalendar(memory);
+
+  let item = new CalEvent();
+  item.id = "test-item-1";
+  item.startDate = cal.dtz.now();
+  item.endDate = cal.dtz.now();
+
+  // Add the item, it still shouldn't be in the deleted database.
+  await check_delmgr_call(() => memory.addItem(item));
+  equal(delmgr.getDeletedDate(item.id), null);
+  equal(delmgr.getDeletedDate(item.id, memory.id), null);
+
+  // We need to stop time so we have something to compare with.
+  let referenceDate = cal.createDateTime("20120726T112045");
+  referenceDate.timezone = cal.dtz.defaultTimezone;
+  let futureDate = cal.createDateTime("20380101T000000");
+  futureDate.timezone = cal.dtz.defaultTimezone;
+  let useFutureDate = false;
+  let oldNowFunction = cal.dtz.now;
+  cal.dtz.now = function () {
+    return (useFutureDate ? futureDate : referenceDate).clone();
+  };
+
+  // Deleting an item should trigger it being marked for deletion.
+  await check_delmgr_call(() => memory.deleteItem(item));
+
+  // Now check if it was deleted at our reference date.
+  let deltime = delmgr.getDeletedDate(item.id);
+  notEqual(deltime, null);
+  equal(deltime.compare(referenceDate), 0);
+
+  // The same with the calendar.
+  deltime = delmgr.getDeletedDate(item.id, memory.id);
+  notEqual(deltime, null);
+  equal(deltime.compare(referenceDate), 0);
+
+  // Item should not be found in other calendars.
+  equal(delmgr.getDeletedDate(item.id, "random"), null);
+
+  // Check if flushing works, we need to travel time for that.
+  useFutureDate = true;
+  await check_delmgr_call(() => delmgr.flush());
+  equal(delmgr.getDeletedDate(item.id), null);
+  equal(delmgr.getDeletedDate(item.id, memory.id), null);
+
+  // Start over with our past time.
+  useFutureDate = false;
+
+  // Add, delete, add. Item should no longer be deleted.
+  await check_delmgr_call(() => memory.addItem(item));
+  equal(delmgr.getDeletedDate(item.id), null);
+  await check_delmgr_call(() => memory.deleteItem(item));
+  equal(delmgr.getDeletedDate(item.id).compare(referenceDate), 0);
+  await check_delmgr_call(() => memory.addItem(item));
+  equal(delmgr.getDeletedDate(item.id), null);
+
+  // Revert now function, in case more tests are written.
+  cal.dtz.now = oldNowFunction;
+});
diff --git a/comm/calendar/test/unit/test_duration.js b/comm/calendar/test/unit/test_duration.js
new file mode 100644
index 0000000000..cef7bbddf9
--- /dev/null
+++ b/comm/calendar/test/unit/test_duration.js
@@ -0,0 +1,10 @@
+/* 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 run_test() {
+  let a = cal.createDuration("PT1S");
+  let b = cal.createDuration("PT3S");
+  a.addDuration(b);
+  equal(a.icalString, "PT4S");
+}
diff --git a/comm/calendar/test/unit/test_email_utils.js b/comm/calendar/test/unit/test_email_utils.js
new file mode 100644
index 0000000000..a1a55e3f17
--- /dev/null
+++ b/comm/calendar/test/unit/test_email_utils.js
@@ -0,0 +1,265 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+});
+
+function run_test() {
+  test_prependMailTo();
+  test_removeMailTo();
+  test_getAttendeeEmail();
+  test_createRecipientList();
+  test_validateRecipientList();
+  test_attendeeMatchesAddresses();
+}
+
+function test_prependMailTo() {
+  let data = [
+    { input: "mailto:first.last@example.net", expected: "mailto:first.last@example.net" },
+    { input: "MAILTO:first.last@example.net", expected: "mailto:first.last@example.net" },
+    { input: "first.last@example.net", expected: "mailto:first.last@example.net" },
+    { input: "first.last.example.net", expected: "first.last.example.net" },
+  ];
+  for (let [i, test] of Object.entries(data)) {
+    equal(cal.email.prependMailTo(test.input), test.expected, "(test #" + i + ")");
+  }
+}
+
+function test_removeMailTo() {
+  let data = [
+    { input: "mailto:first.last@example.net", expected: "first.last@example.net" },
+    { input: "MAILTO:first.last@example.net", expected: "first.last@example.net" },
+    { input: "first.last@example.net", expected: "first.last@example.net" },
+    { input: "first.last.example.net", expected: "first.last.example.net" },
+  ];
+  for (let [i, test] of Object.entries(data)) {
+    equal(cal.email.removeMailTo(test.input), test.expected, "(test #" + i + ")");
+  }
+}
+
+function test_getAttendeeEmail() {
+  let data = [
+    {
+      input: {
+        id: "mailto:first.last@example.net",
+        cname: "Last, First",
+        email: null,
+        useCn: true,
+      },
+      expected: '"Last, First" <first.last@example.net>',
+    },
+    {
+      input: {
+        id: "mailto:first.last@example.net",
+        cname: "Last; First",
+        email: null,
+        useCn: true,
+      },
+      expected: '"Last; First" <first.last@example.net>',
+    },
+    {
+      input: { id: "mailto:first.last@example.net", cname: "First Last", email: null, useCn: true },
+      expected: "First Last <first.last@example.net>",
+    },
+    {
+      input: {
+        id: "mailto:first.last@example.net",
+        cname: "Last, First",
+        email: null,
+        useCn: false,
+      },
+      expected: "first.last@example.net",
+    },
+    {
+      input: { id: "mailto:first.last@example.net", cname: null, email: null, useCn: true },
+      expected: "first.last@example.net",
+    },
+    {
+      input: {
+        id: "urn:uuid:first.last.example.net",
+        cname: null,
+        email: "first.last@example.net",
+        useCn: false,
+      },
+      expected: "first.last@example.net",
+    },
+    {
+      input: {
+        id: "urn:uuid:first.last.example.net",
+        cname: null,
+        email: "first.last@example.net",
+        useCn: true,
+      },
+      expected: "first.last@example.net",
+    },
+    {
+      input: {
+        id: "urn:uuid:first.last.example.net",
+        cname: "First Last",
+        email: "first.last@example.net",
+        useCn: true,
+      },
+      expected: "First Last <first.last@example.net>",
+    },
+    {
+      input: { id: "urn:uuid:first.last.example.net", cname: null, email: null, useCn: false },
+      expected: "",
+    },
+  ];
+  for (let [i, test] of Object.entries(data)) {
+    let attendee = new CalAttendee();
+    attendee.id = test.input.id;
+    if (test.input.cname) {
+      attendee.commonName = test.input.cname;
+    }
+    if (test.input.email) {
+      attendee.setProperty("EMAIL", test.input.email);
+    }
+    equal(
+      cal.email.getAttendeeEmail(attendee, test.input.useCn),
+      test.expected,
+      "(test #" + i + ")"
+    );
+  }
+}
+
+function test_createRecipientList() {
+  let data = [
+    {
+      input: [
+        { id: "mailto:first@example.net", cname: null },
+        { id: "mailto:second@example.net", cname: null },
+        { id: "mailto:third@example.net", cname: null },
+      ],
+      expected: "first@example.net, second@example.net, third@example.net",
+    },
+    {
+      input: [
+        { id: "mailto:first@example.net", cname: "first example" },
+        { id: "mailto:second@example.net", cname: "second example" },
+        { id: "mailto:third@example.net", cname: "third example" },
+      ],
+      expected:
+        "first example <first@example.net>, second example <second@example.net>, " +
+        "third example <third@example.net>",
+    },
+    {
+      input: [
+        { id: "mailto:first@example.net", cname: "example, first" },
+        { id: "mailto:second@example.net", cname: "example, second" },
+        { id: "mailto:third@example.net", cname: "example, third" },
+      ],
+      expected:
+        '"example, first" <first@example.net>, "example, second" <second@example.net>, ' +
+        '"example, third" <third@example.net>',
+    },
+    {
+      input: [
+        { id: "mailto:first@example.net", cname: null },
+        { id: "urn:uuid:second.example.net", cname: null },
+        { id: "mailto:third@example.net", cname: null },
+      ],
+      expected: "first@example.net, third@example.net",
+    },
+    {
+      input: [
+        { id: "mailto:first@example.net", cname: "first" },
+        { id: "urn:uuid:second.example.net", cname: "second" },
+        { id: "mailto:third@example.net", cname: "third" },
+      ],
+      expected: "first <first@example.net>, third <third@example.net>",
+    },
+  ];
+
+  let i = 0;
+  for (let test of data) {
+    i++;
+    let attendees = [];
+    for (let att of test.input) {
+      let attendee = new CalAttendee();
+      attendee.id = att.id;
+      if (att.cname) {
+        attendee.commonName = att.cname;
+      }
+      attendees.push(attendee);
+    }
+    equal(cal.email.createRecipientList(attendees), test.expected, "(test #" + i + ")");
+  }
+}
+
+function test_validateRecipientList() {
+  let data = [
+    {
+      input: "first.last@example.net",
+      expected: "first.last@example.net",
+    },
+    {
+      input: "first last <first.last@example.net>",
+      expected: "first last <first.last@example.net>",
+    },
+    {
+      input: '"last, first" <first.last@example.net>',
+      expected: '"last, first" <first.last@example.net>',
+    },
+    {
+      input: "last, first <first.last@example.net>",
+      expected: '"last, first" <first.last@example.net>',
+    },
+    {
+      input: '"last; first" <first.last@example.net>',
+      expected: '"last; first" <first.last@example.net>',
+    },
+    {
+      input: "first1.last1@example.net,first2.last2@example.net,first3.last2@example.net",
+      expected: "first1.last1@example.net, first2.last2@example.net, first3.last2@example.net",
+    },
+    {
+      input: "first1.last1@example.net, first2.last2@example.net, first3.last2@example.net",
+      expected: "first1.last1@example.net, first2.last2@example.net, first3.last2@example.net",
+    },
+    {
+      input:
+        'first1.last1@example.net, first2 last2 <first2.last2@example.net>, "last3, first' +
+        '3" <first3.last2@example.net>',
+      expected:
+        'first1.last1@example.net, first2 last2 <first2.last2@example.net>, "last3, fi' +
+        'rst3" <first3.last2@example.net>',
+    },
+    {
+      input:
+        'first1.last1@example.net, last2; first2 <first2.last2@example.net>, "last3; first' +
+        '3" <first3.last2@example.net>',
+      expected:
+        'first1.last1@example.net, "last2; first2" <first2.last2@example.net>, "last' +
+        '3; first3" <first3.last2@example.net>',
+    },
+    {
+      input:
+        "first1 last2 <first1.last1@example.net>, last2, first2 <first2.last2@example.net>" +
+        ', "last3, first3" <first3.last2@example.net>',
+      expected:
+        'first1 last2 <first1.last1@example.net>, "last2, first2" <first2.last2@examp' +
+        'le.net>, "last3, first3" <first3.last2@example.net>',
+    },
+  ];
+
+  for (let [i, test] of Object.entries(data)) {
+    equal(cal.email.validateRecipientList(test.input), test.expected, "(test #" + i + ")");
+  }
+}
+
+function test_attendeeMatchesAddresses() {
+  let a = new CalAttendee("ATTENDEE:mailto:horst");
+  ok(cal.email.attendeeMatchesAddresses(a, ["HORST", "peter"]));
+  ok(!cal.email.attendeeMatchesAddresses(a, ["HORSTpeter", "peter"]));
+  ok(!cal.email.attendeeMatchesAddresses(a, ["peter"]));
+
+  a = new CalAttendee('ATTENDEE;EMAIL="horst":urn:uuid:horst');
+  ok(cal.email.attendeeMatchesAddresses(a, ["HORST", "peter"]));
+  ok(!cal.email.attendeeMatchesAddresses(a, ["HORSTpeter", "peter"]));
+  ok(!cal.email.attendeeMatchesAddresses(a, ["peter"]));
+}
diff --git a/comm/calendar/test/unit/test_extract.js b/comm/calendar/test/unit/test_extract.js
new file mode 100644
index 0000000000..96b1729f5c
--- /dev/null
+++ b/comm/calendar/test/unit/test_extract.js
@@ -0,0 +1,225 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// This test works with code that is not timezone-aware.
+/* eslint-disable no-restricted-syntax */
+
+var { Extractor } = ChromeUtils.import("resource:///modules/calendar/calExtract.jsm");
+
+var extractor = new Extractor("en-US", 8);
+
+function run_test() {
+  // Sanity check to make sure the base url is still right. If this fails,
+  // don't forget to also fix the url in base/content/calendar-extract.js.
+  ok(extractor.checkBundle("en-US"));
+
+  test_event_start_end();
+  test_event_start_duration();
+  test_event_start_end_whitespace();
+  test_event_without_date();
+  test_event_next_year();
+  test_task_due();
+  test_overrides();
+  test_event_start_dollar_sign();
+}
+
+function test_event_start_end() {
+  let date = new Date(2012, 9, 1, 9, 0);
+  let title = "Wednesday meetup";
+  let content = "We'll meet at 2 pm and discuss until 3 pm.";
+
+  extractor.extract(title, content, date, undefined);
+  let guessed = extractor.guessStart();
+  let endGuess = extractor.guessEnd(guessed);
+
+  equal(guessed.year, 2012);
+  equal(guessed.month, 10);
+  equal(guessed.day, 3);
+  equal(guessed.hour, 14);
+  equal(guessed.minute, 0);
+
+  equal(endGuess.year, 2012);
+  equal(endGuess.month, 10);
+  equal(endGuess.day, 3);
+  equal(endGuess.hour, 15);
+  equal(endGuess.minute, 0);
+}
+
+function test_event_start_duration() {
+  let date = new Date(2012, 9, 1, 9, 0);
+  let title = "Wednesday meetup";
+  let content = "We'll meet at 2 pm and discuss for 30 minutes.";
+
+  extractor.extract(title, content, date, undefined);
+  let guessed = extractor.guessStart();
+  let endGuess = extractor.guessEnd(guessed);
+
+  equal(guessed.year, 2012);
+  equal(guessed.month, 10);
+  equal(guessed.day, 3);
+  equal(guessed.hour, 14);
+  equal(guessed.minute, 0);
+
+  equal(endGuess.year, 2012);
+  equal(endGuess.month, 10);
+  equal(endGuess.day, 3);
+  equal(endGuess.hour, 14);
+  equal(endGuess.minute, 30);
+}
+
+function test_event_start_end_whitespace() {
+  let date = new Date(2012, 9, 1, 9, 0);
+  let title = "Wednesday meetup";
+  let content = "We'll meet at2pm and discuss until\r\n3pm.";
+
+  extractor.extract(title, content, date, undefined);
+  let guessed = extractor.guessStart();
+  let endGuess = extractor.guessEnd(guessed);
+
+  equal(guessed.year, 2012);
+  equal(guessed.month, 10);
+  equal(guessed.day, 3);
+  equal(guessed.hour, 14);
+  equal(guessed.minute, 0);
+
+  equal(endGuess.year, 2012);
+  equal(endGuess.month, 10);
+  equal(endGuess.day, 3);
+  equal(endGuess.hour, 15);
+  equal(endGuess.minute, 0);
+}
+
+function test_event_without_date() {
+  let date = new Date(2012, 9, 1, 9, 0);
+  let title = "Meetup";
+  let content = "We'll meet at 2 pm and discuss until 3 pm.";
+
+  extractor.extract(title, content, date, undefined);
+  let guessed = extractor.guessStart();
+  let endGuess = extractor.guessEnd(guessed);
+
+  equal(guessed.year, 2012);
+  equal(guessed.month, 10);
+  equal(guessed.day, 1);
+  equal(guessed.hour, 14);
+  equal(guessed.minute, 0);
+
+  equal(endGuess.year, 2012);
+  equal(endGuess.month, 10);
+  equal(endGuess.day, 1);
+  equal(endGuess.hour, 15);
+  equal(endGuess.minute, 0);
+}
+
+function test_event_next_year() {
+  let date = new Date(2012, 9, 1, 9, 0);
+  let title = "Open day";
+  let content = "FYI: Next open day is planned for February 5th.";
+
+  extractor.extract(title, content, date, undefined);
+  let guessed = extractor.guessStart();
+  let endGuess = extractor.guessEnd(guessed);
+
+  equal(guessed.year, 2013);
+  equal(guessed.month, 2);
+  equal(guessed.day, 5);
+  equal(guessed.hour, undefined);
+  equal(guessed.minute, undefined);
+
+  equal(endGuess.year, undefined);
+  equal(endGuess.month, undefined);
+  equal(endGuess.day, undefined);
+  equal(endGuess.hour, undefined);
+  equal(endGuess.minute, undefined);
+}
+
+function test_task_due() {
+  let date = new Date(2012, 9, 1, 9, 0);
+  let title = "Assignment deadline";
+  let content = "This is a reminder that all assignments must be sent in by October 5th!.";
+
+  extractor.extract(title, content, date, undefined);
+  let guessed = extractor.guessStart(true);
+  let endGuess = extractor.guessEnd(guessed, true);
+
+  equal(guessed.year, 2012);
+  equal(guessed.month, 10);
+  equal(guessed.day, 1);
+  equal(guessed.hour, 9);
+  equal(guessed.minute, 0);
+
+  equal(endGuess.year, 2012);
+  equal(endGuess.month, 10);
+  equal(endGuess.day, 5);
+  equal(endGuess.hour, 0);
+  equal(endGuess.minute, 0);
+}
+
+function test_overrides() {
+  let date = new Date(2012, 9, 1, 9, 0);
+  let title = "Event invitation";
+  let content = "We'll meet 10:11 worromot";
+
+  extractor.extract(title, content, date, undefined);
+  let guessed = extractor.guessStart(false);
+  let endGuess = extractor.guessEnd(guessed, true);
+
+  equal(guessed.year, 2012);
+  equal(guessed.month, 10);
+  equal(guessed.day, 1);
+  equal(guessed.hour, 10);
+  equal(guessed.minute, 11);
+
+  equal(endGuess.year, undefined);
+  equal(endGuess.month, undefined);
+  equal(endGuess.day, undefined);
+  equal(endGuess.hour, undefined);
+  equal(endGuess.minute, undefined);
+
+  // recognize a custom "tomorrow" and hour.minutes pattern
+  let overrides = {
+    "from.hour.minutes": { add: "#2:#1", remove: "#1:#2" },
+    "from.tomorrow": { add: "worromot" },
+  };
+
+  Services.prefs.setStringPref("calendar.patterns.override", JSON.stringify(overrides));
+
+  extractor.extract(title, content, date, undefined);
+  guessed = extractor.guessStart(false);
+  endGuess = extractor.guessEnd(guessed, true);
+
+  equal(guessed.year, 2012);
+  equal(guessed.month, 10);
+  equal(guessed.day, 2);
+  equal(guessed.hour, 11);
+  equal(guessed.minute, 10);
+
+  equal(endGuess.year, undefined);
+  equal(endGuess.month, undefined);
+  equal(endGuess.day, undefined);
+  equal(endGuess.hour, undefined);
+  equal(endGuess.minute, undefined);
+}
+
+function test_event_start_dollar_sign() {
+  let date = new Date(2012, 9, 1, 9, 0);
+  let title = "Wednesday sale";
+  let content = "Sale starts at 3 pm and prices start at 2$.";
+
+  extractor.extract(title, content, date, undefined);
+  let guessed = extractor.guessStart();
+  let endGuess = extractor.guessEnd(guessed);
+
+  equal(guessed.year, 2012);
+  equal(guessed.month, 10);
+  equal(guessed.day, 3);
+  equal(guessed.hour, 15);
+  equal(guessed.minute, 0);
+
+  equal(endGuess.year, undefined);
+  equal(endGuess.month, undefined);
+  equal(endGuess.day, undefined);
+  equal(endGuess.hour, undefined);
+  equal(endGuess.minute, undefined);
+}
diff --git a/comm/calendar/test/unit/test_extract_parser.js b/comm/calendar/test/unit/test_extract_parser.js
new file mode 100644
index 0000000000..d1b0f48b80
--- /dev/null
+++ b/comm/calendar/test/unit/test_extract_parser.js
@@ -0,0 +1,160 @@
+/* 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/. */
+
+/**
+ * Tests for the CalExtractParser module.
+ */
+var { CalExtractParseNode, extendParseRule, prepareArguments } = ChromeUtils.import(
+  "resource:///modules/calendar/extract/CalExtractParser.jsm"
+);
+
+/**
+ * Tests to ensure extendParseRule() expands parse rules as we desire.
+ */
+add_task(function testExtendParseRule() {
+  let action = () => {};
+
+  let tests = [
+    {
+      name: "parse rules are expanded correctly",
+      input: {
+        name: "text",
+        patterns: ["TEXT"],
+        action,
+      },
+      expected: {
+        name: "text",
+        patterns: ["TEXT"],
+        action,
+        flags: [0],
+        graph: {
+          symbol: null,
+          flags: null,
+          descendants: [
+            {
+              symbol: "TEXT",
+              flags: 0,
+              descendants: [],
+            },
+          ],
+        },
+      },
+    },
+    {
+      name: "flags are detected correctly",
+      input: {
+        name: "text",
+        patterns: ["CHAR+", "TEXT?", "characters*"],
+        action,
+      },
+      expected: {
+        name: "text",
+        action,
+        patterns: ["CHAR", "TEXT", "characters"],
+        flags: [
+          CalExtractParseNode.FLAG_NONEMPTY | CalExtractParseNode.FLAG_MULTIPLE,
+          CalExtractParseNode.FLAG_OPTIONAL,
+          CalExtractParseNode.FLAG_OPTIONAL | CalExtractParseNode.FLAG_MULTIPLE,
+        ],
+        graph: {
+          symbol: null,
+          flags: null,
+          descendants: [
+            {
+              symbol: "CHAR",
+              flags: CalExtractParseNode.FLAG_NONEMPTY | CalExtractParseNode.FLAG_MULTIPLE,
+              descendants: [
+                {
+                  symbol: "CHAR",
+                },
+                {
+                  symbol: "TEXT",
+                  flags: CalExtractParseNode.FLAG_OPTIONAL,
+                  descendants: [
+                    {
+                      symbol: "characters",
+                      flags: CalExtractParseNode.FLAG_OPTIONAL | CalExtractParseNode.FLAG_MULTIPLE,
+                      descendants: [
+                        {
+                          symbol: "characters",
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      },
+    },
+  ];
+
+  for (let test of tests) {
+    info(`Test extendParseRule(): ${test.name}`);
+    compareExtractResults(extendParseRule(test.input), test.expected);
+  }
+});
+
+/**
+ * Tests prepareArguments() gives the correct arguments.
+ */
+add_task(function testReconcileArguments() {
+  let tests = [
+    {
+      name: "patterns without no flags bits are untouched",
+      rule: {
+        name: "text",
+        patterns: ["CHAR", "TEXT", "characters"],
+        flags: [0, 0, 0],
+      },
+      matched: [
+        ["CHAR", "is char"],
+        ["TEXT", "is text"],
+        ["characters", "is characters"],
+      ],
+      expected: ["is char", "is text", "is characters"],
+    },
+    {
+      name: "multi patterns are turned into arrays",
+      rule: {
+        name: "text",
+        patterns: ["CHAR", "TEXT", "characters"],
+        flags: [
+          CalExtractParseNode.FLAG_NONEMPTY | CalExtractParseNode.FLAG_MULTIPLE,
+          CalExtractParseNode.FLAG_OPTIONAL,
+          CalExtractParseNode.FLAG_OPTIONAL | CalExtractParseNode.FLAG_MULTIPLE,
+        ],
+      },
+      matched: [
+        ["CHAR", "is char"],
+        ["TEXT", "is text"],
+        ["characters", "is characters"],
+      ],
+      expected: [["is char"], "is text", ["is characters"]],
+    },
+    {
+      name: "unmatched optional patterns are null",
+      rule: {
+        name: "text",
+        patterns: ["CHAR", "TEXT", "characters"],
+        flags: [
+          CalExtractParseNode.FLAG_NONEMPTY | CalExtractParseNode.FLAG_MULTIPLE,
+          CalExtractParseNode.FLAG_OPTIONAL,
+          CalExtractParseNode.FLAG_OPTIONAL | CalExtractParseNode.FLAG_MULTIPLE,
+        ],
+      },
+      matched: [
+        ["CHAR", "is char"],
+        ["characters", "is characters"],
+      ],
+      expected: [["is char"], null, ["is characters"]],
+    },
+  ];
+
+  for (let test of tests) {
+    info(`Test prepareArguments(): ${test.name}`);
+    compareExtractResults(prepareArguments(test.rule, test.matched), test.expected);
+  }
+});
diff --git a/comm/calendar/test/unit/test_extract_parser_parse.js b/comm/calendar/test/unit/test_extract_parser_parse.js
new file mode 100644
index 0000000000..ac029c4303
--- /dev/null
+++ b/comm/calendar/test/unit/test_extract_parser_parse.js
@@ -0,0 +1,1317 @@
+/* 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/. */
+
+/**
+ * Tests for the CalExtractParser module.
+ */
+var { CalExtractParser } = ChromeUtils.import(
+  "resource:///modules/calendar/extract/CalExtractParser.jsm"
+);
+
+/**
+ * Tests parsing an empty string produces an empty lit.
+ */
+add_task(function testParseEmptyString() {
+  let parser = new CalExtractParser();
+  let result = parser.parse("");
+  Assert.equal(result.length, 0, "parsing empty string produces empty list");
+});
+
+/**
+ * Tests parsing with various non-flag rules works as expected.
+ */
+add_task(function testParseText() {
+  let parser = CalExtractParser.createInstance(
+    [
+      [/^your/i, "YOUR"],
+      [/^(appointment|meeting|booking)/i, "EVENT"],
+      [/^(at|@)/i, "AT"],
+      [/^on/i, "ON"],
+      [/^\d\d-\d\d-\d\d\d\d/, "DATE"],
+      [/^\d\d\d\d-\d\d-\d\d/, "ISODATE"],
+      [/^(was|is|has been| will be)/i, "BE"],
+      [/^(confirmed|booked|saved|created)/i, "CONFIRM"],
+      [/^[A-Z][A-Za-z0-9]+/, "NOUN"],
+      [/^,/],
+      [/^\S+/, "TEXT"],
+      [/^\s+/],
+    ],
+    [
+      {
+        name: "event",
+        patterns: ["text", "yourevent", "location", "BE", "CONFIRM"],
+        action: ([, title, location]) => ({
+          type: "event",
+          title,
+          location,
+        }),
+      },
+      {
+        name: "event",
+        patterns: ["yourevent", "location", "BE", "CONFIRM"],
+        action: ([title, location]) => ({
+          type: "event",
+          title,
+          location,
+        }),
+      },
+      {
+        name: "event",
+        patterns: ["yourevent", "ON", "date", "BE", "CONFIRM"],
+        action: ([title, , date]) => ({
+          type: "event",
+          title,
+          date,
+        }),
+      },
+      {
+        name: "event",
+        patterns: ["yourthing", "ON", "date", "BE", "CONFIRM"],
+        action: ([title, , date]) => ({
+          type: "event",
+          title,
+          date,
+        }),
+      },
+      {
+        name: "date",
+        patterns: ["DATE"],
+        action: ([value]) => ({
+          type: "date",
+          value,
+        }),
+      },
+      {
+        name: "date",
+        patterns: ["ISODATE"],
+        action: ([value]) => ({
+          type: "date",
+          value,
+        }),
+      },
+      {
+        name: "yourevent",
+        patterns: ["yourthing", "EVENT"],
+        action: ([value]) => value,
+      },
+      {
+        name: "yourthing",
+        patterns: ["YOUR", "text"],
+        action: ([, value]) => value,
+      },
+      {
+        name: "location",
+        patterns: ["AT", "text"],
+        action: ([, value]) => ({
+          type: "location",
+          value,
+        }),
+      },
+      {
+        name: "text",
+        patterns: ["TEXT"],
+        action: ([value]) => value,
+      },
+      {
+        name: "text",
+        patterns: ["NOUN"],
+        action: ([value]) => value,
+      },
+    ]
+  );
+
+  let tests = [
+    {
+      input: "Hello, your banking appointment at RealBank is booked!",
+      expected: [
+        {
+          type: "event",
+          title: {
+            type: "TEXT",
+            text: "banking",
+            sentence: 0,
+            position: 12,
+          },
+          location: {
+            type: "location",
+            value: {
+              type: "NOUN",
+              text: "RealBank",
+              sentence: 0,
+              position: 35,
+            },
+          },
+        },
+      ],
+    },
+    {
+      input: "your banking appointment at RealBank is booked!",
+      expected: [
+        {
+          type: "event",
+          title: {
+            type: "TEXT",
+            text: "banking",
+            sentence: 0,
+            position: 5,
+          },
+          location: {
+            type: "location",
+            value: {
+              type: "NOUN",
+              text: "RealBank",
+              sentence: 0,
+              position: 28,
+            },
+          },
+        },
+      ],
+    },
+    {
+      input: "Your Arraignment on 09-09-2021 is confirmed!",
+      expected: [
+        {
+          type: "event",
+          title: {
+            type: "NOUN",
+            text: "Arraignment",
+            sentence: 0,
+            position: 5,
+          },
+          date: {
+            type: "date",
+            value: {
+              type: "DATE",
+              text: "09-09-2021",
+              sentence: 0,
+              position: 20,
+            },
+          },
+        },
+      ],
+    },
+  ];
+
+  for (let test of tests) {
+    info(`Parsing string "${test.input}"...`);
+    let result = parser.parse(test.input);
+    Assert.equal(
+      result.length,
+      test.expected.length,
+      `parsing "${test.input}" resulted in ${test.expected.length} sentences`
+    );
+    info(`Comparing parse results for string "${test.input}"...`);
+    compareExtractResults(result, test.expected, "result");
+  }
+});
+
+/**
+ * Tests parsing unknown text produces a null result for the sentence.
+ */
+add_task(function testParseUnknownText() {
+  let parser = CalExtractParser.createInstance(
+    [
+      [/^No/, "NO"],
+      [/^rules/, "RULES"],
+      [/^for/, "FOR"],
+      [/^this/, "THIS"],
+      [/^Or/, "OR"],
+      [/^even/, "EVEN"],
+      [/^\s+/, "SPACE"],
+    ],
+    [
+      {
+        name: "statement",
+        patterns: ["NO", "SPACE", "RULES", "SPACE", "FOR", "SPACE", "THIS"],
+        action: () => "statement",
+      },
+      {
+        name: "statement",
+        patterns: ["OR", "SPACE", "THIS"],
+        action: () => "statement",
+      },
+    ]
+  );
+
+  let result = parser.parse("No rules for this. Or this. Or even this!");
+  Assert.equal(result.length, 3, "result has 3 sentences");
+  Assert.equal(result[0], "statement", "first sentence parsed properly");
+  Assert.equal(result[1], "statement", "second sentence parsed properly");
+  Assert.equal(result[2], null, "third sentence was not parsed properly");
+});
+
+/**
+ * Tests parsing without any parse rules produces a null result for each
+ * sentence.
+ */
+add_task(function testParseWithoutParseRules() {
+  let parser = CalExtractParser.createInstance(
+    [
+      [/^[A-Za-z]+/, "TEXT"],
+      [/^\s+/, "SPACE"],
+    ],
+    []
+  );
+  let result = parser.parse("No rules for this. Or this. Or event this!");
+  Assert.equal(result.length, 3, "result has 3 parsed sentences");
+  Assert.ok(
+    result.every(val => val == null),
+    "all parsed results are null"
+  );
+});
+
+/**
+ * Tests parsing using the "+" flag in various scenarios.
+ */
+add_task(function testParseWithPlusFlags() {
+  let parser = CalExtractParser.createInstance(
+    [
+      [/^we\b/i, "WE"],
+      [/^meet\b/i, "MEET"],
+      [/^at\b/i, "AT"],
+      [/^\d/, "NUMBER"],
+      [/^\S+/, "TEXT"],
+      [/^\s+/],
+    ],
+    [
+      {
+        name: "result",
+        patterns: ["subject", "text+", "meet", "time"],
+        action: ([subject, text, , time]) => ({
+          type: "result0",
+          subject,
+          text,
+          time,
+        }),
+      },
+      {
+        name: "result",
+        patterns: ["meet", "time", "text+"],
+        action: ([, time, text]) => ({
+          type: "result1",
+          time,
+          text,
+        }),
+      },
+      {
+        name: "result",
+        patterns: ["text+", "meet", "time"],
+        action: ([text, , time]) => ({
+          type: "result2",
+          time,
+          text,
+        }),
+      },
+      {
+        name: "subject",
+        patterns: ["WE"],
+        action: ([subject]) => ({
+          type: "subject",
+          subject,
+        }),
+      },
+      {
+        name: "meet",
+        patterns: ["MEET", "AT"],
+        action: ([meet, at]) => ({
+          type: "meet",
+          meet,
+          at,
+        }),
+      },
+      {
+        name: "time",
+        patterns: ["NUMBER"],
+        action: ([value]) => ({
+          type: "time",
+          value,
+        }),
+      },
+      {
+        name: "text",
+        patterns: ["TEXT"],
+        action: ([value]) => value,
+      },
+    ]
+  );
+
+  let tests = [
+    {
+      name: "using '+' flag can capture one pattern",
+      input: "We will meet at 7",
+      expected: [
+        {
+          type: "result0",
+          subject: {
+            type: "subject",
+            subject: {
+              type: "WE",
+              text: "We",
+              sentence: 0,
+              position: 0,
+            },
+          },
+          text: [
+            {
+              type: "TEXT",
+              text: "will",
+              sentence: 0,
+              position: 3,
+            },
+          ],
+          time: {
+            type: "time",
+            value: {
+              type: "NUMBER",
+              text: "7",
+              sentence: 0,
+              position: 16,
+            },
+          },
+        },
+      ],
+    },
+    {
+      name: "using the '+' flag can capture multiple patterns",
+      input: "We are coming to meet at 7",
+      expected: [
+        {
+          type: "result0",
+          subject: {
+            type: "subject",
+            subject: {
+              type: "WE",
+              text: "We",
+              sentence: 0,
+              position: 0,
+            },
+          },
+          text: [
+            {
+              type: "TEXT",
+              text: "are",
+              sentence: 0,
+              position: 3,
+            },
+            {
+              type: "TEXT",
+              text: "coming",
+              sentence: 0,
+              position: 7,
+            },
+            {
+              type: "TEXT",
+              text: "to",
+              sentence: 0,
+              position: 14,
+            },
+          ],
+          time: {
+            type: "time",
+            value: { type: "NUMBER", text: "7", sentence: 0, position: 25 },
+          },
+        },
+      ],
+    },
+    {
+      name: "using '+' fails if its pattern is unmatched",
+      input: "We meet at 7",
+      expected: [null],
+    },
+    {
+      name: "'+' can be used in the first position",
+      input: "Well do not meet at 7",
+      expected: [
+        {
+          type: "result2",
+          time: {
+            type: "time",
+            value: {
+              type: "NUMBER",
+              text: "7",
+              sentence: 0,
+              position: 20,
+            },
+          },
+          text: [
+            {
+              type: "TEXT",
+              text: "Well",
+              sentence: 0,
+              position: 0,
+            },
+            {
+              type: "TEXT",
+              text: "do",
+              sentence: 0,
+              position: 5,
+            },
+            {
+              type: "TEXT",
+              text: "not",
+              sentence: 0,
+              position: 8,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      name: "'+' can be used in the last position",
+      input: "Meet at 7 is the plan",
+      expected: [
+        {
+          type: "result1",
+          time: {
+            type: "time",
+            value: {
+              type: "NUMBER",
+              text: "7",
+              sentence: 0,
+              position: 8,
+            },
+          },
+          text: [
+            {
+              type: "TEXT",
+              text: "is",
+              sentence: 0,
+              position: 10,
+            },
+            {
+              type: "TEXT",
+              text: "the",
+              sentence: 0,
+              position: 13,
+            },
+            {
+              type: "TEXT",
+              text: "plan",
+              sentence: 0,
+              position: 17,
+            },
+          ],
+        },
+      ],
+    },
+  ];
+
+  for (let test of tests) {
+    info(`Running test: ${test.name}`);
+    let result = parser.parse(test.input);
+    Assert.equal(
+      result.length,
+      test.expected.length,
+      `parsing "${test.input}" resulted in ${test.expected.length} sentences`
+    );
+    info(`Comparing parse results for string "${test.input}"...`);
+    compareExtractResults(result, test.expected, "result");
+  }
+});
+
+/**
+ * Tests parsing using the "*" flag in various scenarios.
+ */
+add_task(function testParseWithStarFlags() {
+  let parser = CalExtractParser.createInstance(
+    [
+      [/^we\b/i, "WE"],
+      [/^meet\b/i, "MEET"],
+      [/^at\b/i, "AT"],
+      [/^\d/, "NUMBER"],
+      [/^\S+/, "TEXT"],
+      [/^\s+/],
+    ],
+    [
+      {
+        name: "result",
+        patterns: ["subject", "text*", "meet", "time"],
+        action: ([subject, text, , time]) => ({
+          type: "result0",
+          subject,
+          text,
+          time,
+        }),
+      },
+      {
+        name: "result",
+        patterns: ["meet", "time", "text*"],
+        action: ([, time, text]) => ({
+          type: "result1",
+          time,
+          text,
+        }),
+      },
+      {
+        name: "result",
+        patterns: ["text*", "subject", "text", "meet", "time"],
+        action: ([text, subject, , time]) => ({
+          type: "result2",
+          text,
+          subject,
+          time,
+        }),
+      },
+      {
+        name: "subject",
+        patterns: ["WE"],
+        action: ([subject]) => ({
+          type: "subject",
+          subject,
+        }),
+      },
+      {
+        name: "meet",
+        patterns: ["MEET", "AT"],
+        action: ([meet, at]) => ({
+          type: "meet",
+          meet,
+          at,
+        }),
+      },
+      {
+        name: "time",
+        patterns: ["NUMBER"],
+        action: ([value]) => ({
+          type: "time",
+          value,
+        }),
+      },
+      {
+        name: "text",
+        patterns: ["TEXT"],
+        action: ([value]) => value,
+      },
+    ]
+  );
+
+  let tests = [
+    {
+      name: "using '*' flag can capture one pattern",
+      input: "We will meet at 7",
+      expected: [
+        {
+          type: "result0",
+          subject: {
+            type: "subject",
+            subject: {
+              type: "WE",
+              text: "We",
+              sentence: 0,
+              position: 0,
+            },
+          },
+          text: [
+            {
+              type: "TEXT",
+              text: "will",
+              sentence: 0,
+              position: 3,
+            },
+          ],
+          time: {
+            type: "time",
+            value: {
+              type: "NUMBER",
+              text: "7",
+              sentence: 0,
+              position: 16,
+            },
+          },
+        },
+      ],
+    },
+    {
+      name: "using the '*' flag can capture multiple patterns",
+      input: "We are coming to meet at 7",
+      expected: [
+        {
+          type: "result0",
+          subject: {
+            type: "subject",
+            subject: {
+              type: "WE",
+              text: "We",
+              sentence: 0,
+              position: 0,
+            },
+          },
+          text: [
+            {
+              type: "TEXT",
+              text: "are",
+              sentence: 0,
+              position: 3,
+            },
+            {
+              type: "TEXT",
+              text: "coming",
+              sentence: 0,
+              position: 7,
+            },
+            {
+              type: "TEXT",
+              text: "to",
+              sentence: 0,
+              position: 14,
+            },
+          ],
+          time: {
+            type: "time",
+            value: { type: "NUMBER", text: "7", sentence: 0, position: 25 },
+          },
+        },
+      ],
+    },
+    {
+      name: "'*' capture is optional",
+      input: "We meet at 7",
+      expected: [
+        {
+          type: "result0",
+          subject: {
+            type: "subject",
+            subject: {
+              type: "WE",
+              text: "We",
+              sentence: 0,
+              position: 0,
+            },
+          },
+          text: [],
+          time: {
+            type: "time",
+            value: { type: "NUMBER", text: "7", sentence: 0, position: 11 },
+          },
+        },
+      ],
+    },
+    {
+      name: "'*' can be used in the first position",
+      input: "To think we will meet at 7",
+      expected: [
+        {
+          type: "result2",
+          text: [
+            {
+              type: "TEXT",
+              text: "To",
+              sentence: 0,
+              position: 0,
+            },
+            {
+              type: "TEXT",
+              text: "think",
+              sentence: 0,
+              position: 3,
+            },
+          ],
+          subject: {
+            type: "subject",
+            subject: {
+              type: "WE",
+              text: "we",
+              sentence: 0,
+              position: 9,
+            },
+          },
+          time: {
+            type: "meet",
+            meet: {
+              type: "MEET",
+              text: "meet",
+              sentence: 0,
+              position: 17,
+            },
+            at: {
+              type: "AT",
+              text: "at",
+              sentence: 0,
+              position: 22,
+            },
+          },
+        },
+      ],
+    },
+    {
+      name: "'*' can be used in the last position",
+      input: "Meet at 7 is the plan",
+      expected: [
+        {
+          type: "result1",
+          time: {
+            type: "time",
+            value: {
+              type: "NUMBER",
+              text: "7",
+              sentence: 0,
+              position: 8,
+            },
+          },
+          text: [
+            {
+              type: "TEXT",
+              text: "is",
+              sentence: 0,
+              position: 10,
+            },
+            {
+              type: "TEXT",
+              text: "the",
+              sentence: 0,
+              position: 13,
+            },
+            {
+              type: "TEXT",
+              text: "plan",
+              sentence: 0,
+              position: 17,
+            },
+          ],
+        },
+      ],
+    },
+  ];
+
+  for (let test of tests) {
+    info(`Running test: ${test.name}`);
+    let result = parser.parse(test.input);
+    Assert.equal(
+      result.length,
+      test.expected.length,
+      `parsing "${test.input}" resulted in ${test.expected.length} sentences`
+    );
+    info(`Comparing parse results for string "${test.input}"...`);
+    compareExtractResults(result, test.expected, "result");
+  }
+});
+
+/**
+ * Tests parsing using the "?" flag in various scenarios.
+ */
+add_task(function testParseWithOptionalFlags() {
+  let parser = CalExtractParser.createInstance(
+    [
+      [/^we\b/i, "WE"],
+      [/^meet\b/i, "MEET"],
+      [/^at\b/i, "AT"],
+      [/^\d/, "NUMBER"],
+      [/^\S+/, "TEXT"],
+      [/^\s+/],
+    ],
+    [
+      {
+        name: "result",
+        patterns: ["subject", "text?", "meet", "time"],
+        action: ([subject, text, , time]) => ({
+          type: "result0",
+          subject,
+          text,
+          time,
+        }),
+      },
+      {
+        name: "result",
+        patterns: ["meet", "time", "text?"],
+        action: ([, time, text]) => ({
+          type: "result1",
+          time,
+          text,
+        }),
+      },
+      {
+        name: "result",
+        patterns: ["text?", "subject", "text", "meet", "time"],
+        action: ([text, subject, , time]) => ({
+          type: "result2",
+          text,
+          subject,
+          time,
+        }),
+      },
+      {
+        name: "subject",
+        patterns: ["WE"],
+        action: ([subject]) => ({
+          type: "subject",
+          subject,
+        }),
+      },
+      {
+        name: "meet",
+        patterns: ["MEET", "AT"],
+        action: ([meet, at]) => ({
+          type: "meet",
+          meet,
+          at,
+        }),
+      },
+      {
+        name: "time",
+        patterns: ["NUMBER"],
+        action: ([value]) => ({
+          type: "time",
+          value,
+        }),
+      },
+      {
+        name: "text",
+        patterns: ["TEXT"],
+        action: ([value]) => value,
+      },
+    ]
+  );
+
+  let tests = [
+    {
+      name: "using '?' flag can capture one pattern",
+      input: "We will meet at 7",
+      expected: [
+        {
+          type: "result0",
+          subject: {
+            type: "subject",
+            subject: {
+              type: "WE",
+              text: "We",
+              sentence: 0,
+              position: 0,
+            },
+          },
+          text: {
+            type: "TEXT",
+            text: "will",
+            sentence: 0,
+            position: 3,
+          },
+
+          time: {
+            type: "time",
+            value: {
+              type: "NUMBER",
+              text: "7",
+              sentence: 0,
+              position: 16,
+            },
+          },
+        },
+      ],
+    },
+    {
+      name: "'?' capture is optional",
+      input: "We meet at 7",
+      expected: [
+        {
+          type: "result0",
+          subject: {
+            type: "subject",
+            subject: {
+              type: "WE",
+              text: "We",
+              sentence: 0,
+              position: 0,
+            },
+          },
+          text: null,
+          time: {
+            type: "time",
+            value: { type: "NUMBER", text: "7", sentence: 0, position: 11 },
+          },
+        },
+      ],
+    },
+    {
+      name: "'?' can be used in the first position",
+      input: "Think we will meet at 7",
+      expected: [
+        {
+          type: "result2",
+          text: {
+            type: "TEXT",
+            text: "Think",
+            sentence: 0,
+            position: 0,
+          },
+          subject: {
+            type: "subject",
+            subject: {
+              type: "WE",
+              text: "we",
+              sentence: 0,
+              position: 6,
+            },
+          },
+          time: {
+            type: "meet",
+            meet: {
+              type: "MEET",
+              text: "meet",
+              sentence: 0,
+              position: 14,
+            },
+            at: {
+              type: "AT",
+              text: "at",
+              sentence: 0,
+              position: 19,
+            },
+          },
+        },
+      ],
+    },
+    {
+      name: "'?' can be used in the last position",
+      input: "Meet at 7 please",
+      expected: [
+        {
+          type: "result1",
+          time: {
+            type: "time",
+            value: {
+              type: "NUMBER",
+              text: "7",
+              sentence: 0,
+              position: 8,
+            },
+          },
+          text: {
+            type: "TEXT",
+            text: "please",
+            sentence: 0,
+            position: 10,
+          },
+        },
+      ],
+    },
+  ];
+
+  for (let test of tests) {
+    info(`Running test: ${test.name}`);
+    let result = parser.parse(test.input);
+    Assert.equal(
+      result.length,
+      test.expected.length,
+      `parsing "${test.input}" resulted in ${test.expected.length} sentences`
+    );
+    info(`Comparing parse results for string "${test.input}"...`);
+    compareExtractResults(result, test.expected, "result");
+  }
+});
+
+/**
+ * Test the flags can be used together in the same rules.
+ */
+add_task(function testParseWithFlags() {
+  let tokens = [
+    [/^we\b/i, "WE"],
+    [/^meet\b/i, "MEET"],
+    [/^at\b/i, "AT"],
+    [/^\d/, "NUMBER"],
+    [/^\S+/, "TEXT"],
+    [/^\s+/],
+  ];
+
+  let patterns = [
+    {
+      name: "subject",
+      patterns: ["WE"],
+      action: ([subject]) => ({
+        type: "subject",
+        subject,
+      }),
+    },
+    {
+      name: "meet",
+      patterns: ["MEET", "AT"],
+      action: ([meet, at]) => ({
+        type: "meet",
+        meet,
+        at,
+      }),
+    },
+    {
+      name: "time",
+      patterns: ["NUMBER"],
+      action: ([value]) => ({
+        type: "time",
+        value,
+      }),
+    },
+    {
+      name: "text",
+      patterns: ["TEXT"],
+      action: ([value]) => value,
+    },
+  ];
+
+  let tests = [
+    {
+      patterns: ["subject?", "text*", "time+"],
+      variants: [
+        {
+          input: "We will 7",
+          expected: [
+            [
+              {
+                type: "subject",
+                subject: {
+                  type: "WE",
+                  text: "We",
+                  sentence: 0,
+                  position: 0,
+                },
+              },
+              [
+                {
+                  type: "TEXT",
+                  text: "will",
+                  sentence: 0,
+                  position: 3,
+                },
+              ],
+              [
+                {
+                  type: "time",
+                  value: {
+                    type: "NUMBER",
+                    text: "7",
+                    sentence: 0,
+                    position: 8,
+                  },
+                },
+              ],
+            ],
+          ],
+        },
+        {
+          input: "7",
+          expected: [
+            [
+              null,
+              [],
+              [{ type: "time", value: { type: "NUMBER", text: "7", sentence: 0, position: 0 } }],
+            ],
+          ],
+        },
+        {
+          input: "we",
+          expected: [null],
+        },
+        {
+          input: "will 7",
+          expected: [
+            [
+              null,
+              [{ type: "TEXT", text: "will", sentence: 0, position: 0 }],
+              [{ type: "time", value: { type: "NUMBER", text: "7", sentence: 0, position: 5 } }],
+            ],
+          ],
+        },
+        {
+          input: "we 7",
+          expected: [
+            [
+              { type: "subject", subject: { type: "WE", text: "we", sentence: 0, position: 0 } },
+              [],
+              [{ type: "time", value: { type: "NUMBER", text: "7", sentence: 0, position: 3 } }],
+            ],
+          ],
+        },
+      ],
+    },
+    {
+      patterns: ["subject+", "text?", "time*"],
+      variants: [
+        {
+          input: "We will 7",
+          expected: [
+            [
+              [
+                {
+                  type: "subject",
+                  subject: {
+                    type: "WE",
+                    text: "We",
+                    sentence: 0,
+                    position: 0,
+                  },
+                },
+              ],
+              {
+                type: "TEXT",
+                text: "will",
+                sentence: 0,
+                position: 3,
+              },
+
+              [
+                {
+                  type: "time",
+                  value: {
+                    type: "NUMBER",
+                    text: "7",
+                    sentence: 0,
+                    position: 8,
+                  },
+                },
+              ],
+            ],
+          ],
+        },
+        {
+          input: "7",
+          expected: [null],
+        },
+        {
+          input: "will 7",
+          expected: [null],
+        },
+        {
+          input: "we 7",
+          expected: [
+            [
+              [
+                {
+                  type: "subject",
+                  subject: {
+                    type: "WE",
+                    text: "we",
+                    sentence: 0,
+                    position: 0,
+                  },
+                },
+              ],
+              null,
+              [
+                {
+                  type: "time",
+                  value: {
+                    type: "NUMBER",
+                    text: "7",
+                    sentence: 0,
+                    position: 3,
+                  },
+                },
+              ],
+            ],
+          ],
+        },
+      ],
+    },
+    {
+      patterns: ["subject*", "text+", "time?"],
+      variants: [
+        {
+          input: "We will 7",
+          expected: [
+            [
+              [
+                {
+                  type: "subject",
+                  subject: {
+                    type: "WE",
+                    text: "We",
+                    sentence: 0,
+                    position: 0,
+                  },
+                },
+              ],
+              [
+                {
+                  type: "TEXT",
+                  text: "will",
+                  sentence: 0,
+                  position: 3,
+                },
+              ],
+              {
+                type: "time",
+                value: {
+                  type: "NUMBER",
+                  text: "7",
+                  sentence: 0,
+                  position: 8,
+                },
+              },
+            ],
+          ],
+        },
+        {
+          input: "will",
+          expected: [[[], [{ type: "TEXT", text: "will", sentence: 0, position: 0 }], null]],
+        },
+        {
+          input: "will 7",
+          expected: [
+            [
+              [],
+              [
+                {
+                  type: "TEXT",
+                  text: "will",
+                  sentence: 0,
+                  position: 0,
+                },
+              ],
+              {
+                type: "time",
+                value: {
+                  type: "NUMBER",
+                  text: "7",
+                  sentence: 0,
+                  position: 5,
+                },
+              },
+            ],
+          ],
+        },
+        {
+          input: "we will",
+          expected: [
+            [
+              [
+                {
+                  type: "subject",
+                  subject: {
+                    type: "WE",
+                    text: "we",
+                    sentence: 0,
+                    position: 0,
+                  },
+                },
+              ],
+              [
+                {
+                  type: "TEXT",
+                  text: "will",
+                  sentence: 0,
+                  position: 3,
+                },
+              ],
+              null,
+            ],
+          ],
+        },
+      ],
+    },
+  ];
+
+  for (let test of tests) {
+    test = tests[2];
+    let rule = {
+      name: "result",
+      patterns: test.patterns,
+      action: args => args,
+    };
+    let parser = CalExtractParser.createInstance(tokens, [rule, ...patterns]);
+
+    for (let input of test.variants) {
+      input = test.variants[3];
+      info(`Testing pattern: ${test.patterns} with input "${input.input}".`);
+      let result = parser.parse(input.input);
+      info(`Comparing parse results for string "${input.input}"...`);
+      compareExtractResults(result, input.expected, "result");
+    }
+  }
+});
diff --git a/comm/calendar/test/unit/test_extract_parser_service.js b/comm/calendar/test/unit/test_extract_parser_service.js
new file mode 100644
index 0000000000..2118fad16b
--- /dev/null
+++ b/comm/calendar/test/unit/test_extract_parser_service.js
@@ -0,0 +1,96 @@
+/* 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/. */
+
+/**
+ * Tests for the CalExtractParserService. These are modified versions of the
+ * text_extract.js tests, for now.
+ */
+
+// This test works with code that is not timezone-aware.
+/* eslint-disable no-restricted-syntax */
+
+var { CalExtractParserService } = ChromeUtils.import(
+  "resource:///modules/calendar/extract/CalExtractParserService.jsm"
+);
+
+let service = new CalExtractParserService();
+
+/**
+ * Test the extraction of a start and end time using HOUR am/pm. Note: The
+ * service currently only selects event information from one sentence so the
+ * event title is not included here for now.
+ */
+add_task(function test_event_start_end() {
+  let now = new Date(2012, 9, 1, 9, 0);
+  let content = "We'll meet at 2 pm and discuss until 3 pm.";
+  let result = service.extract(content, {
+    now,
+  });
+
+  info(`Comparing extracted result for string "${content}"...`);
+  compareExtractResults(
+    result,
+    {
+      type: "event-guess",
+      startTime: {
+        type: "meridiem-time",
+        year: 2012,
+        month: 10,
+        day: 1,
+        hour: 14,
+        minute: 0,
+        meridiem: "pm",
+      },
+      endTime: {
+        type: "meridiem-time",
+        year: 2012,
+        month: 10,
+        day: 1,
+        hour: 15,
+        minute: 0,
+        meridiem: "pm",
+      },
+      priority: 0,
+    },
+    "result"
+  );
+});
+
+/**
+ * Test the extraction of a start and end time using a meridiem time for start
+ * and a duration for the end.
+ */
+add_task(function test_event_start_duration() {
+  let now = new Date(2012, 9, 1, 9, 0);
+  let content = "We'll meet at 2 pm and discuss for 30 minutes.";
+  let result = service.extract(content, {
+    now,
+  });
+  info(`Comparing extracted result for string "${content}"...`);
+  compareExtractResults(
+    result,
+    {
+      type: "event-guess",
+      startTime: {
+        type: "meridiem-time",
+        year: 2012,
+        month: 10,
+        day: 1,
+        hour: 14,
+        minute: 0,
+        meridiem: "pm",
+      },
+      endTime: {
+        type: "date-time",
+        year: 2012,
+        month: 10,
+        day: 1,
+        hour: 14,
+        minute: 30,
+      },
+      priority: 0,
+    },
+    "result"
+  );
+});
diff --git a/comm/calendar/test/unit/test_extract_parser_tokenize.js b/comm/calendar/test/unit/test_extract_parser_tokenize.js
new file mode 100644
index 0000000000..a77c72bcfc
--- /dev/null
+++ b/comm/calendar/test/unit/test_extract_parser_tokenize.js
@@ -0,0 +1,367 @@
+/* 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/. */
+
+/**
+ * Tests for the CalExtractParser module.
+ */
+var { CalExtractParser } = ChromeUtils.import(
+  "resource:///modules/calendar/extract/CalExtractParser.jsm"
+);
+
+/**
+ * Tests tokenizing an empty string gives an empty list.
+ */
+add_task(function testTokenizeEmptyString() {
+  let parser = new CalExtractParser();
+  let result = parser.tokenize("");
+  Assert.equal(result.length, 0, "tokenize empty string produces empty list");
+});
+
+/**
+ * Tests tokenisation works as expected.
+ */
+add_task(function testTokenizeWithRules() {
+  let parser = new CalExtractParser(
+    [
+      [/^(Monday|Tuesday|Wednesday)/, "DAY"],
+      [/^meet/, "MEET"],
+      [/^[A-Za-z]+/, "TEXT"],
+      [/^[0-9]+/, "NUMBER"],
+      [/^\s+/, "SPACE"],
+      [/^,/, "COMMA"],
+    ],
+    []
+  );
+
+  let text = `Hello there, can we meet on Monday? If not, then Tuesday. We can
+              also meet on Wednesday at 6`;
+
+  let expected = [
+    [
+      {
+        type: "TEXT",
+        text: "Hello",
+        sentence: 0,
+        position: 0,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 0,
+        position: 5,
+      },
+      {
+        type: "TEXT",
+        text: "there",
+        sentence: 0,
+        position: 6,
+      },
+      {
+        type: "COMMA",
+        text: ",",
+        sentence: 0,
+        position: 11,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 0,
+        position: 12,
+      },
+      {
+        type: "TEXT",
+        text: "can",
+        sentence: 0,
+        position: 13,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 0,
+        position: 16,
+      },
+      {
+        type: "TEXT",
+        text: "we",
+        sentence: 0,
+        position: 17,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 0,
+        position: 19,
+      },
+      {
+        type: "MEET",
+        text: "meet",
+        sentence: 0,
+        position: 20,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 0,
+        position: 24,
+      },
+      {
+        type: "TEXT",
+        text: "on",
+        sentence: 0,
+        position: 25,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 0,
+        position: 27,
+      },
+      {
+        type: "DAY",
+        text: "Monday",
+        sentence: 0,
+        position: 28,
+      },
+    ],
+    [
+      {
+        type: "TEXT",
+        text: "If",
+        sentence: 1,
+        position: 0,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 1,
+        position: 2,
+      },
+      {
+        type: "TEXT",
+        text: "not",
+        sentence: 1,
+        position: 3,
+      },
+      {
+        type: "COMMA",
+        text: ",",
+        sentence: 1,
+        position: 6,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 1,
+        position: 7,
+      },
+      {
+        type: "TEXT",
+        text: "then",
+        sentence: 1,
+        position: 8,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 1,
+        position: 12,
+      },
+      {
+        type: "DAY",
+        text: "Tuesday",
+        sentence: 1,
+        position: 13,
+      },
+    ],
+    [
+      {
+        type: "TEXT",
+        text: "We",
+        sentence: 2,
+        position: 0,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 2,
+        position: 2,
+      },
+      {
+        type: "TEXT",
+        text: "can",
+        sentence: 2,
+        position: 3,
+      },
+      {
+        type: "SPACE",
+        text: "\n              ",
+        sentence: 2,
+        position: 6,
+      },
+      {
+        type: "TEXT",
+        text: "also",
+        sentence: 2,
+        position: 21,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 2,
+        position: 25,
+      },
+      {
+        type: "MEET",
+        text: "meet",
+        sentence: 2,
+        position: 26,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 2,
+        position: 30,
+      },
+      {
+        type: "TEXT",
+        text: "on",
+        sentence: 2,
+        position: 31,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 2,
+        position: 33,
+      },
+      {
+        type: "DAY",
+        text: "Wednesday",
+        sentence: 2,
+        position: 34,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 2,
+        position: 43,
+      },
+      {
+        type: "TEXT",
+        text: "at",
+        sentence: 2,
+        position: 44,
+      },
+      {
+        type: "SPACE",
+        text: " ",
+        sentence: 2,
+        position: 46,
+      },
+      {
+        type: "NUMBER",
+        text: "6",
+        sentence: 2,
+        position: 47,
+      },
+    ],
+  ];
+
+  info(`Tokenizing string "${text}"...`);
+  let actual = parser.tokenize(text);
+  Assert.equal(actual.length, expected.length, `result has ${expected.length} sentences`);
+  info(`Comparing results of tokenizing "${text}"...`);
+  for (let i = 0; i < expected.length; i++) {
+    compareExtractResults(actual[i], expected[i], "result");
+  }
+});
+
+/**
+ * Tests tokenizing unknown text produces null.
+ */
+add_task(function testTokenizeUnknownText() {
+  let parser = new CalExtractParser([], []);
+  let result = parser.tokenize("text with no rules");
+  Assert.equal(result.length, 1, "tokenizing unknown text produced a result");
+  Assert.equal(result[0], null, "tokenizing unknown text produced a null result");
+});
+
+/**
+ * Tests omitting some token names omits them from the result.
+ */
+add_task(function testTokenRulesNamesOmitted() {
+  let parser = new CalExtractParser([
+    [/^Monday/, "DAY"],
+    [/^meet/, "MEET"],
+    [/^[A-Za-z]+/, "TEXT"],
+    [/^[0-9]+/, "NUMBER"],
+    [/^\s+/],
+    [/^,/],
+  ]);
+
+  let text = `Hello there, can we meet on Monday?`;
+  let expected = [
+    [
+      {
+        type: "TEXT",
+        text: "Hello",
+        sentence: 0,
+        position: 0,
+      },
+      {
+        type: "TEXT",
+        text: "there",
+        sentence: 0,
+        position: 6,
+      },
+      {
+        type: "TEXT",
+        text: "can",
+        sentence: 0,
+        position: 13,
+      },
+      {
+        type: "TEXT",
+        text: "we",
+        sentence: 0,
+        position: 17,
+      },
+      {
+        type: "MEET",
+        text: "meet",
+        sentence: 0,
+        position: 20,
+      },
+      {
+        type: "TEXT",
+        text: "on",
+        sentence: 0,
+        position: 25,
+      },
+      {
+        type: "DAY",
+        text: "Monday",
+        sentence: 0,
+        position: 28,
+      },
+    ],
+  ];
+
+  info(`Tokenizing string "${text}"...`);
+  let actual = parser.tokenize(text);
+  Assert.equal(actual.length, expected.length, `result has ${expected.length} sentences`);
+  info(`Comparing results of tokenizing string "${text}"..`);
+  for (let i = 0; i < expected.length; i++) {
+    compareExtractResults(actual[i], expected[i], "result");
+  }
+});
+
+/**
+ * Tests parsing an empty string produces an empty lit.
+ */
+add_task(function testParseEmptyString() {
+  let parser = new CalExtractParser();
+  let result = parser.parse("");
+  Assert.equal(result.length, 0, "parsing empty string produces empty list");
+});
diff --git a/comm/calendar/test/unit/test_filter.js b/comm/calendar/test/unit/test_filter.js
new file mode 100644
index 0000000000..3b76585bc6
--- /dev/null
+++ b/comm/calendar/test/unit/test_filter.js
@@ -0,0 +1,406 @@
+/* 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 { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+const { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+const { CalTodo } = ChromeUtils.import("resource:///modules/CalTodo.jsm");
+
+/* globals calFilter, CalReadableStreamFactory */
+Services.scriptloader.loadSubScript("chrome://calendar/content/widgets/calendar-filter.js");
+
+async function promiseItems(filter, calendar) {
+  return cal.iterate.streamToArray(filter.getItems(calendar));
+}
+
+add_task(() => new Promise(resolve => do_calendar_startup(resolve)));
+
+add_task(async function testDateRangeFilter() {
+  let calendar = CalendarTestUtils.createCalendar("test");
+
+  let testItems = {};
+  for (let [title, startDate, endDate] of [
+    ["before", "20210720", "20210721"],
+    ["during", "20210820", "20210821"],
+    ["after", "20210920", "20210921"],
+    ["overlaps_start", "20210720", "20210804"],
+    ["overlaps_end", "20210820", "20210904"],
+    ["overlaps_both", "20210720", "20210904"],
+  ]) {
+    let event = new CalEvent();
+    event.id = cal.getUUID();
+    event.title = title;
+    event.startDate = cal.createDateTime(startDate);
+    event.endDate = cal.createDateTime(endDate);
+    await calendar.addItem(event);
+    testItems[title] = event;
+  }
+
+  // Create a new filter.
+
+  let filter = new calFilter();
+  filter.startDate = cal.createDateTime("20210801");
+  filter.endDate = cal.createDateTime("20210831");
+
+  // Test dateRangeFilter.
+
+  Assert.ok(!filter.dateRangeFilter(testItems.before), "task doesn't pass date range filter");
+  Assert.ok(filter.dateRangeFilter(testItems.during), "task passes date range filter");
+  Assert.ok(!filter.dateRangeFilter(testItems.after), "task doesn't pass date range filter");
+  Assert.ok(filter.dateRangeFilter(testItems.overlaps_start), "task passes date range filter");
+  Assert.ok(filter.dateRangeFilter(testItems.overlaps_end), "task passes date range filter");
+  Assert.ok(filter.dateRangeFilter(testItems.overlaps_both), "task passes date range filter");
+
+  // Test isItemInFilters.
+
+  Assert.ok(!filter.isItemInFilters(testItems.before), "task doesn't pass all filters");
+  Assert.ok(filter.isItemInFilters(testItems.during), "task passes all filters");
+  Assert.ok(!filter.isItemInFilters(testItems.after), "task doesn't pass all filters");
+  Assert.ok(filter.isItemInFilters(testItems.overlaps_start), "task passes all filters");
+  Assert.ok(filter.isItemInFilters(testItems.overlaps_end), "task passes all filters");
+  Assert.ok(filter.isItemInFilters(testItems.overlaps_both), "task passes all filters");
+
+  // Test getItems.
+
+  let items = await promiseItems(filter, calendar);
+  Assert.equal(items.length, 4, "getItems returns expected number of items");
+  Assert.equal(items[0].title, "during", "correct item returned");
+  Assert.equal(items[1].title, "overlaps_start", "correct item returned");
+  Assert.equal(items[2].title, "overlaps_end", "correct item returned");
+  Assert.equal(items[3].title, "overlaps_both", "correct item returned");
+
+  // Change the date of the filter and test it all again.
+
+  filter.startDate = cal.createDateTime("20210825");
+  filter.endDate = cal.createDateTime("20210905");
+
+  // Test dateRangeFilter.
+
+  Assert.ok(!filter.dateRangeFilter(testItems.before), "task doesn't pass date range filter");
+  Assert.ok(!filter.dateRangeFilter(testItems.during), "task passes date range filter");
+  Assert.ok(!filter.dateRangeFilter(testItems.after), "task doesn't pass date range filter");
+  Assert.ok(!filter.dateRangeFilter(testItems.overlaps_start), "task passes date range filter");
+  Assert.ok(filter.dateRangeFilter(testItems.overlaps_end), "task passes date range filter");
+  Assert.ok(filter.dateRangeFilter(testItems.overlaps_both), "task passes date range filter");
+
+  // Test isItemInFilters.
+
+  Assert.ok(!filter.isItemInFilters(testItems.before), "task doesn't pass all filters");
+  Assert.ok(!filter.isItemInFilters(testItems.during), "task passes all filters");
+  Assert.ok(!filter.isItemInFilters(testItems.after), "task doesn't pass all filters");
+  Assert.ok(!filter.isItemInFilters(testItems.overlaps_start), "task passes all filters");
+  Assert.ok(filter.isItemInFilters(testItems.overlaps_end), "task passes all filters");
+  Assert.ok(filter.isItemInFilters(testItems.overlaps_both), "task passes all filters");
+
+  // Test getItems.
+
+  items = await promiseItems(filter, calendar);
+  Assert.equal(items.length, 2, "getItems returns expected number of items");
+  Assert.equal(items[0].title, "overlaps_end", "correct item returned");
+  Assert.equal(items[1].title, "overlaps_both", "correct item returned");
+});
+
+add_task(async function testItemTypeFilter() {
+  let calendar = CalendarTestUtils.createCalendar("test");
+
+  let event = new CalEvent();
+  event.id = cal.getUUID();
+  event.title = "New event";
+  event.startDate = cal.createDateTime("20210803T205500Z");
+  event.endDate = cal.createDateTime("20210803T210200Z");
+  await calendar.addItem(event);
+
+  let task = new CalTodo();
+  task.id = cal.getUUID();
+  task.title = "New task";
+  task.entryDate = cal.createDateTime("20210806T090000Z");
+  task.dueDate = cal.createDateTime("20210810T140000Z");
+  await calendar.addItem(task);
+
+  // Create a new filter.
+
+  let filter = new calFilter();
+  filter.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_ALL;
+  filter.startDate = cal.createDateTime("20210801");
+  filter.endDate = cal.createDateTime("20210831");
+
+  // Check both item types pass ITEM_FILTER_TYPE_ALL.
+
+  Assert.ok(filter.itemTypeFilter(task), "task passes item type filter");
+  Assert.ok(filter.itemTypeFilter(event), "event passes item type filter");
+
+  Assert.ok(filter.isItemInFilters(task), "task passes all filters");
+  Assert.ok(filter.isItemInFilters(event), "event passes all filters");
+
+  let items = await promiseItems(filter, calendar);
+  Assert.equal(items.length, 2, "getItems returns expected number of items");
+  Assert.equal(items[0].title, "New event", "correct item returned");
+  Assert.equal(items[1].title, "New task", "correct item returned");
+
+  // Check only tasks pass ITEM_FILTER_TYPE_TODO.
+
+  filter.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_TODO;
+
+  Assert.ok(filter.itemTypeFilter(task), "task passes item type filter");
+  Assert.ok(!filter.itemTypeFilter(event), "event doesn't pass item type filter");
+
+  Assert.ok(filter.isItemInFilters(task), "task passes all filters");
+  Assert.ok(!filter.isItemInFilters(event), "event doesn't pass all filters");
+
+  items = await promiseItems(filter, calendar);
+  Assert.equal(items.length, 1, "getItems returns expected number of items");
+  Assert.equal(items[0].title, "New task", "correct item returned");
+
+  // Check only events pass ITEM_FILTER_TYPE_EVENT.
+
+  filter.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_EVENT;
+
+  Assert.ok(!filter.itemTypeFilter(task), "task doesn't pass item type filter");
+  Assert.ok(filter.itemTypeFilter(event), "event passes item type filter");
+
+  Assert.ok(!filter.isItemInFilters(task), "task doesn't pass all filters");
+  Assert.ok(filter.isItemInFilters(event), "event passes all filters");
+
+  items = await promiseItems(filter, calendar);
+  Assert.equal(items.length, 1, "getItems returns expected number of items");
+  Assert.equal(items[0].title, "New event", "correct item returned");
+
+  // Check neither tasks or events pass ITEM_FILTER_TYPE_JOURNAL.
+
+  filter.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_JOURNAL;
+
+  Assert.ok(!filter.itemTypeFilter(event), "event doesn't pass item type filter");
+  Assert.ok(!filter.itemTypeFilter(task), "task doesn't pass item type filter");
+
+  Assert.ok(!filter.isItemInFilters(task), "task doesn't pass all filters");
+  Assert.ok(!filter.isItemInFilters(event), "event doesn't pass all filters");
+
+  items = await promiseItems(filter, calendar);
+  Assert.equal(items.length, 0, "getItems returns expected number of items");
+});
+
+add_task(async function testItemTypeFilterTaskCompletion() {
+  let calendar = CalendarTestUtils.createCalendar("test");
+
+  let completeTask = new CalTodo();
+  completeTask.id = cal.getUUID();
+  completeTask.title = "Complete Task";
+  completeTask.entryDate = cal.createDateTime("20210806T090000Z");
+  completeTask.dueDate = cal.createDateTime("20210810T140000Z");
+  completeTask.percentComplete = 100;
+  await calendar.addItem(completeTask);
+
+  let incompleteTask = new CalTodo();
+  incompleteTask.id = cal.getUUID();
+  incompleteTask.title = "Incomplete Task";
+  incompleteTask.entryDate = cal.createDateTime("20210806T090000Z");
+  incompleteTask.dueDate = cal.createDateTime("20210810T140000Z");
+  completeTask.completedDate = null;
+  await calendar.addItem(incompleteTask);
+
+  let filter = new calFilter();
+  filter.startDate = cal.createDateTime("20210801");
+  filter.endDate = cal.createDateTime("20210831");
+
+  let checks = [
+    { flags: Ci.calICalendar.ITEM_FILTER_TYPE_TODO, expectComplete: true, expectIncomplete: true },
+    {
+      flags: Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_YES,
+      expectComplete: true,
+      expectIncomplete: false,
+    },
+    {
+      flags: Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_NO,
+      expectComplete: false,
+      expectIncomplete: true,
+    },
+    {
+      flags: Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL,
+      expectComplete: true,
+      expectIncomplete: true,
+    },
+  ];
+
+  for (let { flags, expectComplete, expectIncomplete } of checks) {
+    info(`testing with flags = ${flags}`);
+    filter.itemType = flags;
+
+    Assert.equal(
+      filter.itemTypeFilter(completeTask),
+      expectComplete,
+      "complete task matches item type filter"
+    );
+    Assert.equal(
+      filter.itemTypeFilter(incompleteTask),
+      expectIncomplete,
+      "incomplete task matches item type filter"
+    );
+
+    Assert.equal(
+      filter.isItemInFilters(completeTask),
+      expectComplete,
+      "complete task matches all filters"
+    );
+    Assert.equal(
+      filter.isItemInFilters(incompleteTask),
+      expectIncomplete,
+      "incomplete task matches all filters"
+    );
+
+    let expectedTitles = [];
+    if (expectComplete) {
+      expectedTitles.push(completeTask.title);
+    }
+    if (expectIncomplete) {
+      expectedTitles.push(incompleteTask.title);
+    }
+    let items = await promiseItems(filter, calendar);
+    Assert.deepEqual(
+      items.map(i => i.title),
+      expectedTitles,
+      "getItems returns correct items"
+    );
+  }
+});
+
+/**
+ * Tests that calFilter.getItems uses the correct flags when calling
+ * calICalendar.getItems. This is important because calFilter is used both by
+ * setting the itemType filter and with a calFilterProperties object.
+ */
+add_task(async function testGetItemsFilterFlags() {
+  let fakeCalendar = {
+    getItems(filter, count, rangeStart, rangeEndEx) {
+      Assert.equal(filter, expected.filter, "getItems called with the right filter");
+      if (expected.rangeStart) {
+        Assert.equal(
+          rangeStart.compare(expected.rangeStart),
+          0,
+          "getItems called with the right start date"
+        );
+      }
+      if (expected.rangeEndEx) {
+        Assert.equal(
+          rangeEndEx.compare(expected.rangeEndEx),
+          0,
+          "getItems called with the right end date"
+        );
+      }
+      return CalReadableStreamFactory.createEmptyReadableStream();
+    },
+  };
+
+  // Test the basic item types.
+  // A request for TODO items requires one of the ITEM_FILTER_COMPLETED flags,
+  // if none are supplied then ITEM_FILTER_COMPLETED_ALL is added.
+  // (These flags have no effect on EVENT items.)
+
+  let filter = new calFilter();
+  let expected = {
+    filter: Ci.calICalendar.ITEM_FILTER_TYPE_ALL | Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL,
+  };
+  filter.getItems(fakeCalendar);
+
+  filter.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_EVENT;
+  expected.filter = Ci.calICalendar.ITEM_FILTER_TYPE_EVENT;
+  filter.getItems(fakeCalendar);
+
+  filter.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_TODO;
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL;
+  filter.getItems(fakeCalendar);
+
+  filter.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_ALL;
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_ALL | Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL;
+  filter.getItems(fakeCalendar);
+
+  // Test that we get occurrences if we have an end date.
+
+  filter.startDate = cal.createDateTime("20220201T000000Z");
+  filter.endDate = cal.createDateTime("20220301T000000Z");
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_ALL |
+    Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL |
+    Ci.calICalendar.ITEM_FILTER_CLASS_OCCURRENCES;
+  expected.rangeStart = filter.startDate;
+  expected.rangeEndEx = filter.endDate;
+  filter.getItems(fakeCalendar);
+
+  filter.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_EVENT;
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_EVENT | Ci.calICalendar.ITEM_FILTER_CLASS_OCCURRENCES;
+  filter.getItems(fakeCalendar);
+
+  filter.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_TODO;
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO |
+    Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL |
+    Ci.calICalendar.ITEM_FILTER_CLASS_OCCURRENCES;
+  filter.getItems(fakeCalendar);
+
+  filter.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_ALL;
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_ALL |
+    Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL |
+    Ci.calICalendar.ITEM_FILTER_CLASS_OCCURRENCES;
+  filter.getItems(fakeCalendar);
+
+  filter.startDate = null;
+  filter.endDate = null;
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_ALL | Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL;
+  delete expected.rangeStart;
+  delete expected.rangeEndEx;
+  filter.getItems(fakeCalendar);
+
+  // Test that completed tasks are correctly filtered.
+
+  filter.itemType =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_YES;
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_YES;
+  filter.getItems(fakeCalendar);
+
+  filter.itemType =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_NO;
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_NO;
+  filter.getItems(fakeCalendar);
+
+  filter.itemType =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL;
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL;
+  filter.getItems(fakeCalendar);
+
+  filter.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_TODO;
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL;
+  filter.getItems(fakeCalendar);
+
+  // Using `applyFilter` needs a selected date or the test dies trying to find the
+  // `currentView` function, which doesn't exist in an XPCShell test.
+  filter.selectedDate = cal.dtz.now();
+  filter.applyFilter("completed");
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO |
+    Ci.calICalendar.ITEM_FILTER_COMPLETED_YES |
+    Ci.calICalendar.ITEM_FILTER_CLASS_OCCURRENCES;
+  filter.getItems(fakeCalendar);
+
+  filter.applyFilter("open");
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_NO;
+  filter.getItems(fakeCalendar);
+
+  filter.applyFilter();
+  expected.filter =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL;
+  filter.getItems(fakeCalendar);
+});
diff --git a/comm/calendar/test/unit/test_filter_mixin.js b/comm/calendar/test/unit/test_filter_mixin.js
new file mode 100644
index 0000000000..0d30afb616
--- /dev/null
+++ b/comm/calendar/test/unit/test_filter_mixin.js
@@ -0,0 +1,1083 @@
+/* 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 { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+const { TestUtils } = ChromeUtils.importESModule("resource://testing-common/TestUtils.sys.mjs");
+
+const { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+const { CalRecurrenceInfo } = ChromeUtils.import("resource:///modules/CalRecurrenceInfo.jsm");
+const { CalTodo } = ChromeUtils.import("resource:///modules/CalTodo.jsm");
+
+/* globals CalendarFilteredViewMixin, CalReadableStreamFactory */
+Services.scriptloader.loadSubScript("chrome://calendar/content/widgets/calendar-filter.js");
+
+class TestCalFilter extends CalendarFilteredViewMixin(class {}) {
+  addedItems = [];
+  removedItems = [];
+  removedCalendarIds = [];
+
+  clearItems() {
+    info("clearItems");
+    this.addedItems.length = 0;
+    this.removedItems.length = 0;
+    this.removedCalendarIds.length = 0;
+  }
+
+  addItems(items) {
+    info("addItems");
+    this.addedItems.push(...items);
+  }
+
+  removeItems(items) {
+    info("removeItems");
+    this.removedItems.push(...items);
+  }
+
+  removeItemsFromCalendar(calendarId) {
+    info("removeItemsFromCalendar");
+    this.removedCalendarIds.push(calendarId);
+  }
+}
+
+let testItems = {};
+let addedTestItems = {};
+
+add_setup(async function () {
+  await new Promise(resolve => do_calendar_startup(resolve));
+
+  for (let [title, startDate, endDate] of [
+    ["before", "20210720", "20210721"],
+    ["during", "20210820", "20210821"],
+    ["after", "20210920", "20210921"],
+    ["overlaps_start", "20210720", "20210804"],
+    ["overlaps_end", "20210820", "20210904"],
+    ["overlaps_both", "20210720", "20210904"],
+  ]) {
+    let item = new CalEvent();
+    item.id = cal.getUUID();
+    item.title = title;
+    item.startDate = cal.createDateTime(startDate);
+    item.endDate = cal.createDateTime(endDate);
+    testItems[title] = item;
+  }
+
+  let repeatingItem = new CalEvent();
+  repeatingItem.id = cal.getUUID();
+  repeatingItem.title = "repeating";
+  repeatingItem.startDate = cal.createDateTime("20210818T120000");
+  repeatingItem.endDate = cal.createDateTime("20210818T130000");
+  repeatingItem.recurrenceInfo = new CalRecurrenceInfo(repeatingItem);
+  repeatingItem.recurrenceInfo.appendRecurrenceItem(
+    cal.createRecurrenceRule("RRULE:FREQ=DAILY;INTERVAL=5;COUNT=4")
+  );
+  testItems.repeating = repeatingItem;
+});
+
+add_task(async function testAddItems() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  for (let title of ["before", "after"]) {
+    testWidget.clearItems();
+    addedTestItems[title] = await calendar.addItem(testItems[title]);
+    Assert.equal(testWidget.addedItems.length, 0);
+  }
+
+  for (let title of ["during", "overlaps_start", "overlaps_end", "overlaps_both"]) {
+    testWidget.clearItems();
+    addedTestItems[title] = await calendar.addItem(testItems[title]);
+
+    Assert.equal(testWidget.addedItems.length, 1);
+    Assert.equal(testWidget.addedItems[0].title, title);
+  }
+
+  testWidget.clearItems();
+  addedTestItems.repeating = await calendar.addItem(testItems.repeating);
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "repeating");
+  Assert.equal(testWidget.addedItems[0].startDate.icalString, "20210818T120000");
+  Assert.equal(testWidget.addedItems[0].endDate.icalString, "20210818T130000");
+  Assert.equal(testWidget.addedItems[1].title, "repeating");
+  Assert.equal(testWidget.addedItems[1].startDate.icalString, "20210823T120000");
+  Assert.equal(testWidget.addedItems[1].endDate.icalString, "20210823T130000");
+  Assert.equal(testWidget.addedItems[2].title, "repeating");
+  Assert.equal(testWidget.addedItems[2].startDate.icalString, "20210828T120000");
+  Assert.equal(testWidget.addedItems[2].endDate.icalString, "20210828T130000");
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testRefresh() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  // Add all calendar items.
+  const promises = [];
+  for (const key in testItems) {
+    promises.push(calendar.addItem(testItems[key]));
+  }
+  await Promise.all(promises);
+
+  testWidget.startDate = cal.createDateTime("20210801");
+  testWidget.endDate = cal.createDateTime("20210831");
+  await testWidget.refreshItems();
+
+  Assert.equal(testWidget.addedItems.length, 7, "getItems returns expected number of items");
+  Assert.equal(testWidget.addedItems[0].title, "during", "correct item returned");
+  Assert.equal(testWidget.addedItems[1].title, "overlaps_start", "correct item returned");
+  Assert.equal(testWidget.addedItems[2].title, "overlaps_end", "correct item returned");
+  Assert.equal(testWidget.addedItems[3].title, "overlaps_both", "correct item returned");
+  Assert.equal(testWidget.addedItems[4].title, "repeating");
+  Assert.equal(testWidget.addedItems[4].startDate.icalString, "20210818T120000");
+  Assert.equal(testWidget.addedItems[4].endDate.icalString, "20210818T130000");
+  Assert.equal(testWidget.addedItems[5].title, "repeating");
+  Assert.equal(testWidget.addedItems[5].startDate.icalString, "20210823T120000");
+  Assert.equal(testWidget.addedItems[5].endDate.icalString, "20210823T130000");
+  Assert.equal(testWidget.addedItems[6].title, "repeating");
+  Assert.equal(testWidget.addedItems[6].startDate.icalString, "20210828T120000");
+  Assert.equal(testWidget.addedItems[6].endDate.icalString, "20210828T130000");
+
+  testWidget.startDate = cal.createDateTime("20210825");
+  testWidget.endDate = cal.createDateTime("20210905");
+  await testWidget.refreshItems();
+
+  Assert.equal(testWidget.addedItems.length, 4, "getItems returns expected number of items");
+  Assert.equal(testWidget.addedItems[0].title, "overlaps_end", "correct item returned");
+  Assert.equal(testWidget.addedItems[1].title, "overlaps_both", "correct item returned");
+  Assert.equal(testWidget.addedItems[2].title, "repeating");
+  Assert.equal(testWidget.addedItems[2].startDate.icalString, "20210828T120000");
+  Assert.equal(testWidget.addedItems[2].endDate.icalString, "20210828T130000");
+  Assert.equal(testWidget.addedItems[3].title, "repeating");
+  Assert.equal(testWidget.addedItems[3].startDate.icalString, "20210902T120000");
+  Assert.equal(testWidget.addedItems[3].endDate.icalString, "20210902T130000");
+
+  // Verify that refreshing while the widget is inactive doesn't prevent later
+  // attempts to refresh from succeeding.
+  testWidget.deactivate();
+  testWidget.clearItems();
+  Assert.equal(
+    testWidget.addedItems.length,
+    0,
+    "there should be no items after deactivation and clearing"
+  );
+
+  await testWidget.refreshItems();
+  Assert.equal(testWidget.addedItems.length, 0, "refreshing while inactive should not add items");
+
+  await testWidget.activate();
+  Assert.equal(testWidget.addedItems.length, 4, "getItems returns expected number of items");
+  Assert.equal(testWidget.addedItems[0].title, "overlaps_end", "correct item returned");
+  Assert.equal(testWidget.addedItems[1].title, "overlaps_both", "correct item returned");
+  Assert.equal(testWidget.addedItems[2].title, "repeating");
+  Assert.equal(testWidget.addedItems[2].startDate.icalString, "20210828T120000");
+  Assert.equal(testWidget.addedItems[2].endDate.icalString, "20210828T130000");
+  Assert.equal(testWidget.addedItems[3].title, "repeating");
+  Assert.equal(testWidget.addedItems[3].startDate.icalString, "20210902T120000");
+  Assert.equal(testWidget.addedItems[3].endDate.icalString, "20210902T130000");
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testRemoveItems() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  for (let title of ["before", "after"]) {
+    testWidget.clearItems();
+    await calendar.deleteItem(addedTestItems[title]);
+    Assert.equal(testWidget.removedItems.length, 0);
+  }
+
+  for (let title of ["during", "overlaps_start", "overlaps_end", "overlaps_both"]) {
+    testWidget.clearItems();
+    await calendar.deleteItem(addedTestItems[title]);
+
+    Assert.equal(testWidget.removedItems.length, 1);
+    Assert.equal(testWidget.removedItems[0].title, title);
+  }
+
+  testWidget.clearItems();
+  await calendar.deleteItem(addedTestItems.repeating);
+
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.equal(testWidget.removedItems[0].title, "repeating");
+  Assert.equal(testWidget.removedItems[0].startDate.icalString, "20210818T120000");
+  Assert.equal(testWidget.removedItems[0].endDate.icalString, "20210818T130000");
+  Assert.equal(testWidget.removedItems[1].title, "repeating");
+  Assert.equal(testWidget.removedItems[1].startDate.icalString, "20210823T120000");
+  Assert.equal(testWidget.removedItems[1].endDate.icalString, "20210823T130000");
+  Assert.equal(testWidget.removedItems[2].title, "repeating");
+  Assert.equal(testWidget.removedItems[2].startDate.icalString, "20210828T120000");
+  Assert.equal(testWidget.removedItems[2].endDate.icalString, "20210828T130000");
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testModifyItem() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "change me";
+  item.startDate = cal.createDateTime("20210805T170000");
+  item.endDate = cal.createDateTime("20210805T180000");
+
+  testWidget.clearItems();
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 1);
+  Assert.equal(testWidget.addedItems[0].title, "change me");
+
+  let changedItem = item.clone();
+  changedItem.title = "changed";
+
+  let addedItems = testWidget.addedItems.slice();
+  testWidget.clearItems();
+  await calendar.modifyItem(changedItem, item);
+
+  Assert.equal(testWidget.addedItems.length, 1);
+  Assert.equal(testWidget.addedItems[0].title, "changed");
+  Assert.ok(testWidget.addedItems[0].hasSameIds(addedItems[0]));
+  Assert.equal(testWidget.removedItems.length, 1);
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+
+  testWidget.clearItems();
+  await calendar.deleteItem(changedItem);
+
+  Assert.equal(testWidget.removedItems.length, 1);
+  Assert.equal(testWidget.removedItems[0].title, "changed");
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testMoveItemWithinRange() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "move me";
+  item.startDate = cal.createDateTime("20210805T170000");
+  item.endDate = cal.createDateTime("20210805T180000");
+
+  testWidget.clearItems();
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 1);
+  Assert.equal(testWidget.addedItems[0].title, "move me");
+
+  let changedItem = item.clone();
+  changedItem.startDate = cal.createDateTime("20210805T180000");
+  changedItem.endDate = cal.createDateTime("20210805T190000");
+
+  let addedItems = testWidget.addedItems.slice();
+  testWidget.clearItems();
+  await calendar.modifyItem(changedItem, item);
+
+  Assert.equal(testWidget.addedItems.length, 1);
+  Assert.equal(testWidget.addedItems[0].title, "move me");
+  Assert.ok(testWidget.addedItems[0].hasSameIds(addedItems[0]));
+  Assert.equal(testWidget.removedItems.length, 1);
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+
+  testWidget.clearItems();
+  await calendar.deleteItem(changedItem);
+
+  Assert.equal(testWidget.removedItems.length, 1);
+  Assert.equal(testWidget.removedItems[0].title, "move me");
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testMoveItemOutOfRange() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "move me";
+  item.startDate = cal.createDateTime("20210805T170000");
+  item.endDate = cal.createDateTime("20210805T180000");
+
+  testWidget.clearItems();
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 1);
+  Assert.equal(testWidget.addedItems[0].title, "move me");
+
+  let changedItem = item.clone();
+  changedItem.startDate = cal.createDateTime("20210905T170000");
+  changedItem.endDate = cal.createDateTime("20210905T180000");
+
+  let addedItems = testWidget.addedItems.slice();
+  testWidget.clearItems();
+  await calendar.modifyItem(changedItem, item);
+
+  Assert.equal(testWidget.addedItems.length, 0);
+  Assert.equal(testWidget.removedItems.length, 1);
+  Assert.equal(testWidget.removedItems[0].title, "move me");
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+
+  testWidget.clearItems();
+  await calendar.deleteItem(changedItem);
+
+  Assert.equal(testWidget.removedItems.length, 0);
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testMoveItemInToRange() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "move me";
+  item.startDate = cal.createDateTime("20210705T170000");
+  item.endDate = cal.createDateTime("20210705T180000");
+
+  testWidget.clearItems();
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 0);
+
+  let changedItem = item.clone();
+  changedItem.startDate = cal.createDateTime("20210805T170000");
+  changedItem.endDate = cal.createDateTime("20210805T180000");
+
+  await calendar.modifyItem(changedItem, item);
+
+  Assert.equal(testWidget.addedItems.length, 1);
+  Assert.equal(testWidget.addedItems[0].title, "move me");
+  Assert.equal(testWidget.removedItems.length, 0);
+
+  await calendar.deleteItem(changedItem);
+
+  Assert.equal(testWidget.removedItems.length, 1);
+  Assert.equal(testWidget.removedItems[0].title, "move me");
+  Assert.ok(testWidget.removedItems[0].hasSameIds(testWidget.addedItems[0]));
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testModifyRecurringItem() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "change me";
+  item.startDate = cal.createDateTime("20210805T170000");
+  item.endDate = cal.createDateTime("20210805T180000");
+  item.recurrenceInfo = new CalRecurrenceInfo(item);
+  item.recurrenceInfo.appendRecurrenceItem(cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=3"));
+
+  testWidget.clearItems();
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "change me");
+  Assert.equal(testWidget.addedItems[1].title, "change me");
+  Assert.equal(testWidget.addedItems[2].title, "change me");
+
+  let changedItem = item.clone();
+  changedItem.title = "changed";
+
+  let addedItems = testWidget.addedItems.slice();
+  testWidget.clearItems();
+  await calendar.modifyItem(changedItem, item);
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "changed");
+  Assert.equal(testWidget.addedItems[1].title, "changed");
+  Assert.equal(testWidget.addedItems[2].title, "changed");
+  Assert.ok(testWidget.addedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.addedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.addedItems[2].hasSameIds(addedItems[2]));
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(addedItems[2]));
+
+  testWidget.clearItems();
+  await calendar.deleteItem(changedItem);
+
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.equal(testWidget.removedItems[0].title, "changed");
+  Assert.equal(testWidget.removedItems[1].title, "changed");
+  Assert.equal(testWidget.removedItems[2].title, "changed");
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(addedItems[2]));
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testMoveRecurringItemWithinRange() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "move me";
+  item.startDate = cal.createDateTime("20210805T170000");
+  item.endDate = cal.createDateTime("20210805T180000");
+  item.recurrenceInfo = new CalRecurrenceInfo(item);
+  item.recurrenceInfo.appendRecurrenceItem(cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=3"));
+
+  testWidget.clearItems();
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "move me");
+  Assert.equal(testWidget.addedItems[1].title, "move me");
+  Assert.equal(testWidget.addedItems[2].title, "move me");
+
+  let changedItem = item.clone();
+  changedItem.startDate = cal.createDateTime("20210805T180000");
+  changedItem.endDate = cal.createDateTime("20210805T190000");
+
+  let addedItems = testWidget.addedItems.slice();
+  testWidget.clearItems();
+  await calendar.modifyItem(changedItem, item);
+
+  // This maybe should call modifyItems, but instead it calls addItems and removeItems.
+
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.equal(testWidget.removedItems[0].title, "move me");
+  Assert.equal(testWidget.removedItems[1].title, "move me");
+  Assert.equal(testWidget.removedItems[2].title, "move me");
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(addedItems[2]));
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "move me");
+  Assert.equal(testWidget.addedItems[1].title, "move me");
+  Assert.equal(testWidget.addedItems[2].title, "move me");
+  Assert.equal(testWidget.addedItems[0].startDate.icalString, "20210805T180000");
+  Assert.equal(testWidget.addedItems[1].startDate.icalString, "20210806T180000");
+  Assert.equal(testWidget.addedItems[2].startDate.icalString, "20210807T180000");
+  Assert.equal(testWidget.addedItems[0].endDate.icalString, "20210805T190000");
+  Assert.equal(testWidget.addedItems[1].endDate.icalString, "20210806T190000");
+  Assert.equal(testWidget.addedItems[2].endDate.icalString, "20210807T190000");
+
+  addedItems = testWidget.addedItems.slice();
+  testWidget.clearItems();
+  await calendar.deleteItem(changedItem);
+
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.equal(testWidget.removedItems[0].title, "move me");
+  Assert.equal(testWidget.removedItems[1].title, "move me");
+  Assert.equal(testWidget.removedItems[2].title, "move me");
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(addedItems[2]));
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testMoveRecurringItemOutOfRange() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "move me";
+  item.startDate = cal.createDateTime("20210805T170000");
+  item.endDate = cal.createDateTime("20210805T180000");
+  item.recurrenceInfo = new CalRecurrenceInfo(item);
+  item.recurrenceInfo.appendRecurrenceItem(cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=3"));
+
+  testWidget.clearItems();
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "move me");
+  Assert.equal(testWidget.addedItems[1].title, "move me");
+  Assert.equal(testWidget.addedItems[2].title, "move me");
+
+  let changedItem = item.clone();
+  changedItem.startDate = cal.createDateTime("20210905T170000");
+  changedItem.endDate = cal.createDateTime("20210905T180000");
+
+  let addedItems = testWidget.addedItems.slice();
+  testWidget.clearItems();
+  await calendar.modifyItem(changedItem, item);
+
+  Assert.equal(testWidget.addedItems.length, 0);
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.equal(testWidget.removedItems[0].title, "move me");
+  Assert.equal(testWidget.removedItems[1].title, "move me");
+  Assert.equal(testWidget.removedItems[2].title, "move me");
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(addedItems[2]));
+
+  testWidget.clearItems();
+  await calendar.deleteItem(changedItem);
+
+  Assert.equal(testWidget.removedItems.length, 0);
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testMoveRecurringItemInToRange() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "move me";
+  item.startDate = cal.createDateTime("20210705T170000");
+  item.endDate = cal.createDateTime("20210705T180000");
+  item.recurrenceInfo = new CalRecurrenceInfo(item);
+  item.recurrenceInfo.appendRecurrenceItem(cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=3"));
+
+  testWidget.clearItems();
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 0);
+
+  let changedItem = item.clone();
+  changedItem.startDate = cal.createDateTime("20210805T170000");
+  changedItem.endDate = cal.createDateTime("20210805T180000");
+
+  await calendar.modifyItem(changedItem, item);
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "move me");
+  Assert.equal(testWidget.addedItems[1].title, "move me");
+  Assert.equal(testWidget.addedItems[2].title, "move me");
+  Assert.equal(testWidget.removedItems.length, 0);
+
+  await calendar.deleteItem(changedItem);
+
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.equal(testWidget.removedItems[0].title, "move me");
+  Assert.equal(testWidget.removedItems[1].title, "move me");
+  Assert.equal(testWidget.removedItems[2].title, "move me");
+  Assert.ok(testWidget.removedItems[0].hasSameIds(testWidget.addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(testWidget.addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(testWidget.addedItems[2]));
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testModifyOccurrence() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "change me";
+  item.startDate = cal.createDateTime("20210805T170000");
+  item.endDate = cal.createDateTime("20210805T180000");
+  item.recurrenceInfo = new CalRecurrenceInfo(item);
+  item.recurrenceInfo.appendRecurrenceItem(cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=3"));
+
+  testWidget.clearItems();
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "change me");
+  Assert.equal(testWidget.addedItems[1].title, "change me");
+  Assert.equal(testWidget.addedItems[2].title, "change me");
+
+  let occurrences = item.recurrenceInfo.getOccurrences(
+    testWidget.startDate,
+    testWidget.endDate,
+    100
+  );
+  let changedOccurrence = occurrences[1].clone();
+  changedOccurrence.title = "changed";
+
+  let addedItems = testWidget.addedItems.slice();
+  testWidget.clearItems();
+  await calendar.modifyItem(
+    cal.itip.prepareSequence(changedOccurrence, occurrences[1]),
+    occurrences[1]
+  );
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "change me");
+  Assert.equal(testWidget.addedItems[1].title, "changed");
+  Assert.equal(testWidget.addedItems[2].title, "change me");
+  Assert.ok(testWidget.addedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.addedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.addedItems[2].hasSameIds(addedItems[2]));
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(addedItems[2]));
+
+  testWidget.clearItems();
+  await calendar.deleteItem(item);
+
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(addedItems[2]));
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testDeleteOccurrence() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "change me";
+  item.startDate = cal.createDateTime("20210805T170000");
+  item.endDate = cal.createDateTime("20210805T180000");
+  item.recurrenceInfo = new CalRecurrenceInfo(item);
+  item.recurrenceInfo.appendRecurrenceItem(cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=3"));
+
+  testWidget.clearItems();
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "change me");
+  Assert.equal(testWidget.addedItems[1].title, "change me");
+  Assert.equal(testWidget.addedItems[2].title, "change me");
+
+  let changedItem = item.clone();
+  let occurrences = changedItem.recurrenceInfo.getOccurrences(
+    testWidget.startDate,
+    testWidget.endDate,
+    100
+  );
+  changedItem.recurrenceInfo.removeOccurrenceAt(occurrences[1].recurrenceId);
+
+  let addedItems = testWidget.addedItems.slice();
+  testWidget.clearItems();
+  await calendar.modifyItem(changedItem, item);
+
+  Assert.equal(testWidget.addedItems.length, 2);
+  Assert.equal(testWidget.addedItems[0].title, "change me");
+  Assert.equal(testWidget.addedItems[1].title, "change me");
+  Assert.ok(testWidget.addedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.addedItems[1].hasSameIds(addedItems[2]));
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(addedItems[2]));
+
+  testWidget.clearItems();
+  await calendar.deleteItem(item);
+
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(addedItems[2]));
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testMoveOccurrenceWithinRange() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "move me";
+  item.startDate = cal.createDateTime("20210805T170000");
+  item.endDate = cal.createDateTime("20210805T180000");
+  item.recurrenceInfo = new CalRecurrenceInfo(item);
+  item.recurrenceInfo.appendRecurrenceItem(cal.createRecurrenceRule("RRULE:FREQ=DAILY;COUNT=3"));
+
+  testWidget.clearItems();
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "move me");
+  Assert.equal(testWidget.addedItems[1].title, "move me");
+  Assert.equal(testWidget.addedItems[2].title, "move me");
+
+  let occurrences = item.recurrenceInfo.getOccurrences(
+    testWidget.startDate,
+    testWidget.endDate,
+    100
+  );
+  let changedOccurrence = occurrences[1].clone();
+  changedOccurrence.startDate = cal.createDateTime("20210806T173000");
+  changedOccurrence.endDate = cal.createDateTime("20210806T183000");
+
+  let addedItems = testWidget.addedItems.slice();
+  testWidget.clearItems();
+  await calendar.modifyItem(
+    cal.itip.prepareSequence(changedOccurrence, occurrences[1]),
+    occurrences[1]
+  );
+
+  Assert.equal(testWidget.addedItems.length, 3);
+  Assert.equal(testWidget.addedItems[0].title, "move me");
+  Assert.equal(testWidget.addedItems[1].title, "move me");
+  Assert.equal(testWidget.addedItems[2].title, "move me");
+  Assert.equal(testWidget.addedItems[0].startDate.icalString, "20210805T170000");
+  Assert.equal(testWidget.addedItems[1].startDate.icalString, "20210806T173000");
+  Assert.equal(testWidget.addedItems[2].startDate.icalString, "20210807T170000");
+  Assert.equal(testWidget.addedItems[0].endDate.icalString, "20210805T180000");
+  Assert.equal(testWidget.addedItems[1].endDate.icalString, "20210806T183000");
+  Assert.equal(testWidget.addedItems[2].endDate.icalString, "20210807T180000");
+  Assert.ok(testWidget.addedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.addedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.addedItems[2].hasSameIds(addedItems[2]));
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(addedItems[2]));
+
+  testWidget.clearItems();
+  await calendar.deleteItem(item);
+
+  Assert.equal(testWidget.removedItems.length, 3);
+  Assert.equal(testWidget.removedItems[0].title, "move me");
+  Assert.equal(testWidget.removedItems[1].title, "move me");
+  Assert.equal(testWidget.removedItems[2].title, "move me");
+  Assert.ok(testWidget.removedItems[0].hasSameIds(addedItems[0]));
+  Assert.ok(testWidget.removedItems[1].hasSameIds(addedItems[1]));
+  Assert.ok(testWidget.removedItems[2].hasSameIds(addedItems[2]));
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testChangeTaskCompletion() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let incompleteTask = new CalTodo();
+  incompleteTask.id = cal.getUUID();
+  incompleteTask.title = "incomplete task";
+  incompleteTask.startDate = cal.createDateTime("20210805T170000");
+  incompleteTask.endDate = cal.createDateTime("20210805T180000");
+
+  // Set the widget to only show incomplete tasks.
+
+  testWidget.itemType =
+    Ci.calICalendar.ITEM_FILTER_TYPE_TODO | Ci.calICalendar.ITEM_FILTER_COMPLETED_NO;
+
+  // Add an incomplete task to the calendar.
+
+  testWidget.clearItems();
+  incompleteTask = await calendar.addItem(incompleteTask);
+
+  Assert.equal(testWidget.addedItems.length, 1, "incomplete item was added");
+  Assert.equal(testWidget.addedItems[0].title, "incomplete task");
+
+  // Complete the task. It should be removed from the widget.
+
+  let completeTask = incompleteTask.clone();
+  completeTask.title = "complete task";
+  completeTask.percentComplete = 100;
+
+  testWidget.clearItems();
+  completeTask = await calendar.modifyItem(completeTask, incompleteTask);
+
+  Assert.equal(testWidget.removedItems.length, 1, "complete item was removed");
+  Assert.equal(testWidget.removedItems[0].title, "incomplete task");
+
+  // Mark the task as incomplete again. It should be added back to the widget.
+
+  let incompleteAgainItem = completeTask.clone();
+  incompleteAgainItem.title = "incomplete again task";
+  incompleteAgainItem.percentComplete = 50;
+
+  testWidget.clearItems();
+  await calendar.modifyItem(incompleteAgainItem, completeTask);
+
+  Assert.equal(testWidget.addedItems.length, 1, "incomplete item was added");
+  Assert.equal(testWidget.addedItems[0].title, "incomplete again task");
+
+  // Clean up.
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testDisableEnableCalendar() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  addedTestItems.during = await calendar.addItem(testItems.during);
+
+  Assert.equal(testWidget.addedItems.length, 1);
+  Assert.equal(testWidget.removedItems.length, 0);
+  Assert.equal(testWidget.removedCalendarIds.length, 0);
+
+  // Test disabling and enabling the calendar.
+
+  testWidget.clearItems();
+  calendar.setProperty("disabled", true);
+  Assert.equal(testWidget.addedItems.length, 0);
+  Assert.equal(testWidget.removedItems.length, 0);
+  Assert.deepEqual(testWidget.removedCalendarIds, [calendar.id]);
+
+  testWidget.clearItems();
+  calendar.setProperty("disabled", false);
+  await TestUtils.waitForCondition(() => testWidget.addedItems.length == 1);
+  Assert.equal(testWidget.addedItems.length, 1);
+  Assert.equal(testWidget.removedItems.length, 0);
+  Assert.equal(testWidget.removedCalendarIds.length, 0);
+
+  // Test hiding and showing the calendar.
+
+  testWidget.clearItems();
+  calendar.setProperty("calendar-main-in-composite", false);
+  Assert.equal(testWidget.addedItems.length, 0);
+  Assert.equal(testWidget.removedItems.length, 0);
+  Assert.deepEqual(testWidget.removedCalendarIds, [calendar.id]);
+
+  testWidget.clearItems();
+  calendar.setProperty("calendar-main-in-composite", true);
+  await TestUtils.waitForCondition(() => testWidget.addedItems.length == 1);
+  Assert.equal(testWidget.addedItems.length, 1);
+  Assert.equal(testWidget.removedItems.length, 0);
+  Assert.equal(testWidget.removedCalendarIds.length, 0);
+
+  // Test disabling and enabling the calendar while it is hidden.
+
+  testWidget.clearItems();
+  calendar.setProperty("calendar-main-in-composite", false);
+  Assert.equal(testWidget.addedItems.length, 0);
+  Assert.equal(testWidget.removedItems.length, 0);
+  Assert.deepEqual(testWidget.removedCalendarIds, [calendar.id]);
+
+  testWidget.clearItems();
+  calendar.setProperty("disabled", true);
+  Assert.equal(testWidget.addedItems.length, 0);
+  Assert.equal(testWidget.removedItems.length, 0);
+  Assert.deepEqual(testWidget.removedCalendarIds, [calendar.id]);
+
+  testWidget.clearItems();
+  calendar.setProperty("disabled", false);
+  await new Promise(resolve => do_timeout(500, resolve));
+  Assert.equal(testWidget.addedItems.length, 0);
+  Assert.equal(testWidget.removedItems.length, 0);
+  Assert.equal(testWidget.removedCalendarIds.length, 0);
+
+  testWidget.clearItems();
+  calendar.setProperty("calendar-main-in-composite", true);
+  await TestUtils.waitForCondition(() => testWidget.addedItems.length == 1);
+  Assert.equal(testWidget.addedItems.length, 1);
+  Assert.equal(testWidget.removedItems.length, 0);
+  Assert.equal(testWidget.removedCalendarIds.length, 0);
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testChangeWhileHidden() {
+  const { calendar, testWidget } = await initializeCalendarAndTestWidget();
+
+  let item = new CalEvent();
+  item.id = cal.getUUID();
+  item.title = "change me";
+  item.startDate = cal.createDateTime("20210805T170000");
+  item.endDate = cal.createDateTime("20210805T180000");
+
+  testWidget.clearItems();
+  calendar.setProperty("calendar-main-in-composite", false);
+  item = await calendar.addItem(item);
+
+  Assert.equal(testWidget.addedItems.length, 0);
+  Assert.equal(testWidget.removedItems.length, 0);
+
+  let changedItem = item.clone();
+  changedItem.title = "changed";
+  await calendar.modifyItem(changedItem, item);
+
+  Assert.equal(testWidget.addedItems.length, 0);
+  Assert.equal(testWidget.removedItems.length, 0);
+
+  await calendar.deleteItem(changedItem);
+
+  Assert.equal(testWidget.addedItems.length, 0);
+  Assert.equal(testWidget.removedItems.length, 0);
+
+  CalendarTestUtils.removeCalendar(calendar);
+  testWidget.deactivate();
+});
+
+add_task(async function testChangeWhileRefreshing() {
+  // Create a calendar we can control the output of.
+
+  let pumpCalendar = {
+    type: "pump",
+    uri: Services.io.newURI("pump:test-calendar"),
+    getProperty(name) {
+      switch (name) {
+        case "disabled":
+          return false;
+        case "calendar-main-in-composite":
+          return true;
+      }
+      return null;
+    },
+    addObserver() {},
+
+    getItems(filter, count, rangeStart, rangeEndEx) {
+      return CalReadableStreamFactory.createReadableStream({
+        async start(controller) {
+          pumpCalendar.controller = controller;
+        },
+      });
+    },
+  };
+  cal.manager.registerCalendar(pumpCalendar);
+
+  // Create a new widget and a Promise waiting for it to be ready.
+
+  let widget = new TestCalFilter();
+  widget.id = "test-filter";
+  widget.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_ALL;
+
+  let ready1 = widget.ready;
+  let ready1Resolved, ready1Rejected;
+  ready1.then(
+    arg => {
+      ready1Resolved = true;
+    },
+    arg => {
+      ready1Rejected = true;
+    }
+  );
+
+  // Ask the calendars for items. Get a waiting Promise before and after doing so.
+  // These should be the same as the earlier Promise.
+
+  Assert.equal(widget.ready, ready1, ".ready should return the same Promise");
+  Assert.equal(widget.activate(), ready1, ".activate should return the same Promise");
+  Assert.equal(widget.ready, ready1, ".ready should return the same Promise");
+
+  // Return some items from the calendar. They should be sent to addItems.
+
+  pumpCalendar.controller.enqueue([testItems.during]);
+  await TestUtils.waitForCondition(() => widget.addedItems.length == 1, "first added item");
+  Assert.equal(widget.addedItems[0].title, testItems.during.title, "added item was expected");
+
+  // Make the widget inactive. This invalidates the earlier call to `refreshItems`.
+
+  widget.deactivate();
+
+  // Return some more items from the calendar. These should be ignored.
+
+  // Even though the data is now invalid the original Promise should not have been replaced with a
+  // new one.
+
+  Assert.equal(widget.ready, ready1, ".ready should return the same Promise");
+
+  pumpCalendar.controller.enqueue([testItems.after]);
+  pumpCalendar.controller.close();
+
+  // We're testing that nothing happens. Give it time to potentially happen.
+  await new Promise(resolve => do_timeout(500, resolve));
+
+  Assert.equal(widget.addedItems.length, 1, "no more items added");
+  Assert.equal(widget.addedItems[0].title, testItems.during.title, "added item was expected");
+  Assert.equal(ready1Resolved, undefined, "Promise did not yet resolve");
+  Assert.equal(ready1Rejected, undefined, "Promise did not yet reject");
+
+  // Make the widget active again so we can test some other things.
+
+  widget.clearItems();
+
+  Assert.equal(widget.activate(), ready1, ".activate should return the same Promise");
+  Assert.equal(widget.ready, ready1, ".ready should return the same Promise");
+
+  pumpCalendar.controller.enqueue([testItems.during]);
+  await TestUtils.waitForCondition(() => widget.addedItems.length == 1, "first added item");
+  Assert.equal(widget.addedItems[0].title, testItems.during.title, "added item was expected");
+
+  // ... then before it finishes, force another refresh. We're still waiting for the original
+  // Promise because no refresh has completed yet.
+  // Return a different item, just to be sure we got the one we expected.
+
+  Assert.equal(widget.refreshItems(true), ready1, ".refreshItems should return the same Promise");
+  Assert.equal(widget.addedItems.length, 0, "items were cleared");
+
+  pumpCalendar.controller.enqueue([testItems.before]);
+  pumpCalendar.controller.close();
+
+  // Finally we have a completed refresh. The Promise should resolve now.
+
+  await ready1;
+  await TestUtils.waitForCondition(() => widget.addedItems.length == 1, "first added item");
+  Assert.equal(widget.addedItems[0].title, testItems.before.title, "added item was expected");
+
+  // The Promise should not be replaced until the dates or item type change, or we force a refresh.
+
+  Assert.equal(widget.ready, ready1, ".ready should return the same Promise");
+  Assert.equal(widget.refreshItems(), ready1, ".refreshItems should return the same Promise");
+
+  // Force refresh again. There should be a new ready Promise, since the old one was resolved and
+  // we forced a refresh.
+
+  let ready2 = widget.refreshItems(true);
+  Assert.notEqual(ready2, ready1, ".refreshItems should return a new Promise");
+  Assert.equal(widget.addedItems.length, 0, "items were cleared");
+
+  pumpCalendar.controller.enqueue([testItems.after]);
+  pumpCalendar.controller.close();
+
+  await ready2;
+  await TestUtils.waitForCondition(() => widget.addedItems.length == 1, "first added item");
+  Assert.equal(widget.addedItems[0].title, testItems.after.title, "added item was expected");
+
+  // Change the item type. There should be a new ready Promise, since the old one was resolved and
+  // the item type changed.
+
+  widget.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_EVENT;
+  let ready3 = widget.ready;
+  Assert.notEqual(ready3, ready2, ".ready should return a new Promise");
+  Assert.equal(widget.refreshItems(), ready3, ".refreshItems should return the same Promise");
+  Assert.equal(widget.addedItems.length, 0, "items were cleared");
+
+  pumpCalendar.controller.enqueue([testItems.during]);
+  pumpCalendar.controller.close();
+
+  await ready3;
+  await TestUtils.waitForCondition(() => widget.addedItems.length == 1, "first added item");
+  Assert.equal(widget.addedItems[0].title, testItems.during.title, "added item was expected");
+
+  // Change the start date. There should be a new ready Promise, since the old one was resolved and
+  // the start date changed.
+
+  widget.startDate = cal.createDateTime("20220317");
+  let ready4 = widget.ready;
+  Assert.notEqual(ready4, ready3, ".ready should return a new Promise");
+  Assert.equal(widget.refreshItems(), ready4, ".refreshItems should return the same Promise");
+
+  pumpCalendar.controller.close();
+  await ready4;
+
+  // Change the end date. There should be a new ready Promise, since the old one was resolved and
+  // the end date changed.
+
+  widget.endDate = cal.createDateTime("20220318");
+  let ready5 = widget.ready;
+  Assert.notEqual(ready5, ready4, ".ready should return a new Promise");
+  Assert.equal(widget.refreshItems(), ready5, ".refreshItems should return the same Promise");
+
+  pumpCalendar.controller.close();
+  await ready5;
+});
+
+async function initializeCalendarAndTestWidget() {
+  const calendar = CalendarTestUtils.createCalendar("test", "storage");
+  calendar.setProperty("calendar-main-in-composite", true);
+
+  const testWidget = new TestCalFilter();
+  testWidget.startDate = cal.createDateTime("20210801");
+  testWidget.endDate = cal.createDateTime("20210831");
+  testWidget.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_ALL;
+  await testWidget.activate();
+
+  return { calendar, testWidget };
+}
diff --git a/comm/calendar/test/unit/test_filter_tree_view.js b/comm/calendar/test/unit/test_filter_tree_view.js
new file mode 100644
index 0000000000..97313849c4
--- /dev/null
+++ b/comm/calendar/test/unit/test_filter_tree_view.js
@@ -0,0 +1,451 @@
+/* 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 { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+const { TestUtils } = ChromeUtils.importESModule("resource://testing-common/TestUtils.sys.mjs");
+
+const { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+const { CalRecurrenceInfo } = ChromeUtils.import("resource:///modules/CalRecurrenceInfo.jsm");
+const { CalRecurrenceRule } = ChromeUtils.import("resource:///modules/CalRecurrenceRule.jsm");
+
+const { TreeSelection } = ChromeUtils.importESModule(
+  "chrome://messenger/content/tree-selection.mjs"
+);
+
+Services.scriptloader.loadSubScript("chrome://messenger/content/jsTreeView.js");
+Services.scriptloader.loadSubScript("chrome://calendar/content/widgets/calendar-filter.js");
+/* globals CalendarFilteredTreeView */
+Services.scriptloader.loadSubScript(
+  "chrome://calendar/content/widgets/calendar-filter-tree-view.js"
+);
+
+const testItems = {};
+
+add_setup(async function () {
+  await new Promise(resolve => do_calendar_startup(resolve));
+
+  // Create events useful for testing.
+  for (const [title, startDate, endDate] of [
+    ["one", "20221126T010000", "20221126T013000"],
+    ["two", "20221126T020000", "20221126T073000"],
+    ["three", "20221126T030000", "20221126T033000"],
+    ["four", "20221126T040000", "20221126T043000"],
+    ["five", "20221126T050000", "20221126T053000"],
+    ["six", "20221126T060000", "20221126T063000"],
+  ]) {
+    const item = new CalEvent();
+    item.id = cal.getUUID();
+    item.title = title;
+    item.startDate = cal.createDateTime(startDate);
+    item.endDate = cal.createDateTime(endDate);
+    testItems[title] = item;
+  }
+
+  const recurring = new CalEvent();
+  recurring.id = cal.getUUID();
+  recurring.title = "recurring event";
+  recurring.startDate = cal.createDateTime("20221124T053000");
+  recurring.endDate = cal.createDateTime("20221124T063000");
+
+  const recurRule = cal.createRecurrenceRule();
+  recurRule.type = "DAILY";
+  recurRule.byCount = true;
+  recurRule.count = 5;
+
+  const recurInfo = new CalRecurrenceInfo(recurring);
+  recurInfo.appendRecurrenceItem(recurRule);
+
+  recurring.recurrenceInfo = recurInfo;
+
+  testItems.recurring = recurring;
+});
+
+add_task(async function testAddItemsAndSort() {
+  const { calendar, view } = await initializeCalendarAndView();
+
+  assertViewContainsItemsInOrder(view);
+
+  await calendar.addItem(testItems.one);
+  assertViewContainsItemsInOrder(view, "one");
+
+  await calendar.addItem(testItems.three);
+  await calendar.addItem(testItems.four);
+  assertViewContainsItemsInOrder(view, "one", "three", "four");
+
+  // Verify that items are sorted by start time by default.
+  await calendar.addItem(testItems.two);
+  assertViewContainsItemsInOrder(view, "one", "two", "three", "four");
+
+  // Change sort to ascending by title.
+  view.cycleHeader({ id: "title" });
+  assertViewContainsItemsInOrder(view, "four", "one", "three", "two");
+
+  // Verify that items are sorted appropriately on add.
+  await calendar.addItem(testItems.five);
+  assertViewContainsItemsInOrder(view, "five", "four", "one", "three", "two");
+
+  // Change sort to descending by title.
+  view.cycleHeader({ id: "title" });
+  assertViewContainsItemsInOrder(view, "two", "three", "one", "four", "five");
+
+  await calendar.addItem(testItems.six);
+  assertViewContainsItemsInOrder(view, "two", "three", "six", "one", "four", "five");
+
+  // Re-sort by start date for testing recurrences.
+  view.cycleHeader({ id: "startDate" });
+
+  // Verify that recurring events which occur more than once in the filter range
+  // show up more than once. Also verify that occurrences outside the filter
+  // range do not display.
+  await calendar.addItem(testItems.recurring);
+  assertViewContainsItemsInOrder(
+    view,
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "recurring event",
+    "six",
+    "recurring event"
+  );
+
+  CalendarTestUtils.removeCalendar(calendar);
+  view.deactivate();
+});
+
+add_task(async function testInitializeWithExistingCalenderEvents() {
+  const calendar = CalendarTestUtils.createCalendar("test", "storage");
+  calendar.setProperty("calendar-main-in-composite", true);
+
+  // Add items to the calendar before we initialize the view.
+  await calendar.addItem(testItems.one);
+  await calendar.addItem(testItems.three);
+  await calendar.addItem(testItems.four);
+
+  const view = new CalendarFilteredTreeView();
+  view.startDate = cal.createDateTime("20221126");
+  view.endDate = cal.createDateTime("20221128");
+  view.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_EVENT;
+
+  const tree = {
+    _batchUpdated: false,
+    _batchDepth: false,
+
+    beginUpdateBatch() {},
+    endUpdateBatch() {},
+    invalidateRow(index) {},
+  };
+  view.setTree(tree);
+
+  // Wait for the view to fetch items and update.
+  await view.activate();
+
+  // Verify that items added to the calendar before initializing are displayed.
+  assertViewContainsItemsInOrder(view, "one", "three", "four");
+
+  // Verify that adding further items causes them to be displayed as well.
+  await calendar.addItem(testItems.two);
+  assertViewContainsItemsInOrder(view, "one", "two", "three", "four");
+
+  CalendarTestUtils.removeCalendar(calendar);
+  view.deactivate();
+});
+
+add_task(async function testRemoveItems() {
+  const { calendar, view } = await initializeCalendarAndView();
+
+  // Record the calendar items so we can use them to delete.
+  const calendarItems = {};
+  for (const key in testItems) {
+    calendarItems[key] = await calendar.addItem(testItems[key]);
+  }
+
+  // Sanity check.
+  assertViewContainsItemsInOrder(
+    view,
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "recurring event",
+    "six",
+    "recurring event"
+  );
+
+  await calendar.deleteItem(calendarItems.two);
+  assertViewContainsItemsInOrder(
+    view,
+    "one",
+    "three",
+    "four",
+    "five",
+    "recurring event",
+    "six",
+    "recurring event"
+  );
+
+  // Verify that all occurrences of recurring items are removed.
+  await calendar.deleteItem(calendarItems.recurring);
+  assertViewContainsItemsInOrder(view, "one", "three", "four", "five", "six");
+
+  await calendar.deleteItem(calendarItems.three);
+  await calendar.deleteItem(calendarItems.four);
+  assertViewContainsItemsInOrder(view, "one", "five", "six");
+
+  // Verify that sort order doesn't impact removal.
+  view.cycleHeader({ id: "title" });
+  await calendar.deleteItem(calendarItems.five);
+  assertViewContainsItemsInOrder(view, "one", "six");
+
+  CalendarTestUtils.removeCalendar(calendar);
+  view.deactivate();
+});
+
+add_task(async function testClearItems() {
+  const { calendar, view } = await initializeCalendarAndView();
+
+  // Add all calendar items.
+  const promises = [];
+  for (const key in testItems) {
+    promises.push(calendar.addItem(testItems[key]));
+  }
+  await Promise.all(promises);
+
+  // Sanity check.
+  assertViewContainsItemsInOrder(
+    view,
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "recurring event",
+    "six",
+    "recurring event"
+  );
+
+  // Directly call clear, as there isn't a convenient way to trigger it via the
+  // calendar.
+  view.clearItems();
+
+  assertViewContainsItemsInOrder(view);
+
+  CalendarTestUtils.removeCalendar(calendar);
+  view.deactivate();
+});
+
+add_task(async function testFilterFunction() {
+  const { calendar, view } = await initializeCalendarAndView();
+
+  // Add some items which will match the filter and some which won't.
+  const promises = [];
+  for (const key of ["one", "two", "five", "recurring"]) {
+    promises.push(calendar.addItem(testItems[key]));
+  }
+  await Promise.all(promises);
+
+  // Add a selection to ensure that selections don't persist when filter changes.
+  view.selection.toggleSelect(0);
+
+  // Sanity check.
+  assertViewContainsItemsInOrder(view, "one", "two", "five", "recurring event", "recurring event");
+  Assert.ok(view.selection.isSelected(0), "item 'one' should be selected");
+
+  // Verify that setting filter function appropriately hides non-matching items.
+  view.setFilterFunction(item => {
+    return item.title.includes("f");
+  });
+  assertViewContainsItemsInOrder(view, "five");
+  Assert.ok(!view.selection.isSelected(0), "item 'five' should not be selected");
+
+  // Verify that matching items display when added.
+  await calendar.addItem(testItems.four);
+  assertViewContainsItemsInOrder(view, "four", "five");
+
+  // Verify that sorting respects filter.
+  view.cycleHeader({ id: "title" });
+  assertViewContainsItemsInOrder(view, "five", "four");
+
+  // Verify that non-matching items don't display when added.
+  await calendar.addItem(testItems.six);
+  assertViewContainsItemsInOrder(view, "five", "four");
+
+  // Verify that clearing the filter shows all items properly sorted.
+  view.clearFilter();
+  assertViewContainsItemsInOrder(
+    view,
+    "five",
+    "four",
+    "one",
+    "recurring event",
+    "recurring event",
+    "six",
+    "two"
+  );
+
+  CalendarTestUtils.removeCalendar(calendar);
+  view.deactivate();
+});
+
+add_task(async function testRemoveItemsFromCalendar() {
+  const { calendar, view } = await initializeCalendarAndView();
+
+  const secondCalendar = CalendarTestUtils.createCalendar("test", "storage");
+  secondCalendar.setProperty("calendar-main-in-composite", true);
+
+  const promises = [];
+
+  // Add some items to the first calendar.
+  for (const key of ["one", "two", "five", "recurring"]) {
+    promises.push(calendar.addItem(testItems[key]));
+  }
+
+  // Add the rest to the second calendar.
+  for (const key of ["three", "four", "six"]) {
+    promises.push(secondCalendar.addItem(testItems[key]));
+  }
+
+  await Promise.all(promises);
+
+  // Verify that both calendars are displayed.
+  assertViewContainsItemsInOrder(
+    view,
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "recurring event",
+    "six",
+    "recurring event"
+  );
+
+  // Verify that removing items from a specific calendar removes exactly those
+  // events from the view.
+  view.removeItemsFromCalendar(calendar.id);
+
+  assertViewContainsItemsInOrder(view, "three", "four", "six");
+
+  CalendarTestUtils.removeCalendar(calendar);
+  CalendarTestUtils.removeCalendar(secondCalendar);
+  view.deactivate();
+});
+
+add_task(async function testSortRespectsSelection() {
+  const { calendar, view } = await initializeCalendarAndView();
+
+  // Add all calendar items.
+  const promises = [];
+  for (const key in testItems) {
+    promises.push(calendar.addItem(testItems[key]));
+  }
+  await Promise.all(promises);
+
+  view.selection.toggleSelect(1);
+  view.selection.toggleSelect(5);
+  view.selection.toggleSelect(6);
+
+  view.selection.currentIndex = 1;
+
+  // Sanity check.
+  assertViewContainsItemsInOrder(
+    view,
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "recurring event",
+    "six",
+    "recurring event"
+  );
+
+  // Sanity check selection; two, recurring event, and six should be selected,
+  // nothing else.
+  Assert.ok(view.selection.isSelected(1), "item 'two' should be selected");
+  Assert.ok(view.selection.isSelected(5), "item 'recurring event' should be selected");
+  Assert.ok(view.selection.isSelected(6), "item 'three' should be selected");
+  Assert.equal(view.selection.currentIndex, 1, "item 'two' should be the current selection");
+  for (const row of [0, 2, 3, 4, 7]) {
+    Assert.ok(!view.selection.isSelected(row), `row ${row} should not be selected`);
+  }
+
+  // Verify that sorting the tree keeps the same events selected.
+  view.cycleHeader({ id: "title" });
+
+  assertViewContainsItemsInOrder(
+    view,
+    "five",
+    "four",
+    "one",
+    "recurring event",
+    "recurring event",
+    "six",
+    "three",
+    "two"
+  );
+
+  Assert.ok(view.selection.isSelected(7), "item 'two' should remain selected");
+  Assert.ok(view.selection.isSelected(5), "item 'recurring event' should remain selected");
+  Assert.ok(view.selection.isSelected(3), "item 'three' should remain selected");
+  Assert.equal(view.selection.currentIndex, 7, "item 'two' should be the current selection");
+  for (const row of [0, 1, 2, 4, 6]) {
+    Assert.ok(!view.selection.isSelected(row), `row ${row} should not be selected`);
+  }
+
+  CalendarTestUtils.removeCalendar(calendar);
+  view.deactivate();
+});
+
+function assertViewContainsItemsInOrder(view, ...expected) {
+  const actual = [];
+  for (let i = 0; i < view.rowCount; i++) {
+    actual.push(view.getCellText(i, { id: "title" }));
+  }
+
+  // Check array length. We don't use Assert.equal() here in order to provide
+  // better debugging output.
+  if (actual.length != expected.length) {
+    Assert.report(
+      actual.length != expected.length,
+      actual,
+      expected,
+      `${JSON.stringify(actual)} should have the same length as ${JSON.stringify(expected)}`
+    );
+  }
+
+  Assert.deepEqual(actual, expected);
+}
+
+async function initializeCalendarAndView() {
+  const calendar = CalendarTestUtils.createCalendar("test", "storage");
+  calendar.setProperty("calendar-main-in-composite", true);
+
+  const view = new CalendarFilteredTreeView();
+  view.startDate = cal.createDateTime("20221126");
+  view.endDate = cal.createDateTime("20221128");
+  view.itemType = Ci.calICalendar.ITEM_FILTER_TYPE_EVENT;
+  view.activate();
+
+  const tree = {
+    _batchUpdated: false,
+    _batchDepth: false,
+
+    beginUpdateBatch() {},
+    endUpdateBatch() {},
+    invalidateRow(index) {},
+  };
+  view.setTree(tree);
+
+  const selection = new TreeSelection(tree);
+  selection.view = view;
+  view.selection = selection;
+  selection.clearSelection();
+
+  return { calendar, view };
+}
diff --git a/comm/calendar/test/unit/test_freebusy.js b/comm/calendar/test/unit/test_freebusy.js
new file mode 100644
index 0000000000..73ac60fb3d
--- /dev/null
+++ b/comm/calendar/test/unit/test_freebusy.js
@@ -0,0 +1,88 @@
+/* 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 run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  test_freebusy();
+  test_period();
+}
+
+function test_freebusy() {
+  let icsService = Cc["@mozilla.org/calendar/ics-service;1"].getService(Ci.calIICSService);
+
+  // Bug 415987 - FREEBUSY decoding does not support comma-separated entries
+  // (https://bugzilla.mozilla.org/show_bug.cgi?id=415987)
+  let fbVal1 = "20080206T160000Z/PT1H";
+  let fbVal2 = "20080206T180000Z/PT1H";
+  let fbVal3 = "20080206T220000Z/PT1H";
+  let data =
+    "BEGIN:VCALENDAR\n" +
+    "BEGIN:VFREEBUSY\n" +
+    "FREEBUSY;FBTYPE=BUSY:" +
+    fbVal1 +
+    "," +
+    fbVal2 +
+    "," +
+    fbVal3 +
+    "\n" +
+    "END:VFREEBUSY\n" +
+    "END:VCALENDAR\n";
+  let fbComp = icsService.parseICS(data).getFirstSubcomponent("VFREEBUSY");
+  equal(fbComp.getFirstProperty("FREEBUSY").value, fbVal1);
+  equal(fbComp.getNextProperty("FREEBUSY").value, fbVal2);
+  equal(fbComp.getNextProperty("FREEBUSY").value, fbVal3);
+}
+
+function test_period() {
+  let period = Cc["@mozilla.org/calendar/period;1"].createInstance(Ci.calIPeriod);
+
+  period.start = cal.createDateTime("20120101T010101");
+  period.end = cal.createDateTime("20120101T010102");
+
+  equal(period.icalString, "20120101T010101/20120101T010102");
+  equal(period.duration.icalString, "PT1S");
+
+  period.icalString = "20120101T010103/20120101T010104";
+
+  equal(period.start.icalString, "20120101T010103");
+  equal(period.end.icalString, "20120101T010104");
+  equal(period.duration.icalString, "PT1S");
+
+  period.icalString = "20120101T010105/PT1S";
+  equal(period.start.icalString, "20120101T010105");
+  equal(period.end.icalString, "20120101T010106");
+  equal(period.duration.icalString, "PT1S");
+
+  period.makeImmutable();
+  // ical.js doesn't support immutability yet
+  // throws(
+  //   () => {
+  //     period.start = cal.createDateTime("20120202T020202");
+  //   },
+  //   /0x80460002/,
+  //   "Object is Immutable"
+  // );
+  // throws(
+  //   () => {
+  //     period.end = cal.createDateTime("20120202T020202");
+  //   },
+  //   /0x80460002/,
+  //   "Object is Immutable"
+  // );
+
+  let copy = period.clone();
+  equal(copy.start.icalString, "20120101T010105");
+  equal(copy.end.icalString, "20120101T010106");
+  equal(copy.duration.icalString, "PT1S");
+
+  copy.start.icalString = "20120101T010106";
+  copy.end = cal.createDateTime("20120101T010107");
+
+  equal(period.start.icalString, "20120101T010105");
+  equal(period.end.icalString, "20120101T010106");
+  equal(period.duration.icalString, "PT1S");
+}
diff --git a/comm/calendar/test/unit/test_freebusy_service.js b/comm/calendar/test/unit/test_freebusy_service.js
new file mode 100644
index 0000000000..e19d51f943
--- /dev/null
+++ b/comm/calendar/test/unit/test_freebusy_service.js
@@ -0,0 +1,201 @@
+/* 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 freebusy = Cc["@mozilla.org/calendar/freebusy-service;1"].getService(Ci.calIFreeBusyService);
+
+function run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  test_found();
+  test_noproviders();
+  test_failure();
+  test_cancel();
+}
+
+function test_found() {
+  _clearProviders();
+
+  equal(_countProviders(), 0);
+
+  let provider1 = {
+    id: 1,
+    getFreeBusyIntervals(aCalId, aStart, aEnd, aTypes, aListener) {
+      aListener.onResult(null, []);
+    },
+  };
+
+  let provider2 = {
+    id: 2,
+    called: false,
+    getFreeBusyIntervals(aCalId, aStart, aEnd, aTypes, aListener) {
+      ok(!this.called);
+      this.called = true;
+
+      let interval = new cal.provider.FreeBusyInterval(
+        aCalId,
+        Ci.calIFreeBusyInterval.BUSY,
+        aStart,
+        aEnd
+      );
+      aListener.onResult(null, [interval]);
+    },
+  };
+  provider2.wrappedJSObject = provider2;
+
+  freebusy.addProvider(provider1);
+  equal(_countProviders(), 1);
+  freebusy.addProvider(provider2);
+  equal(_countProviders(), 2);
+  freebusy.removeProvider(provider1);
+  equal(_countProviders(), 1);
+  equal(_getFirstProvider().id, 2);
+
+  let listener = {
+    called: false,
+    onResult(request, result) {
+      equal(result.length, 1);
+      equal(result[0].interval.start.icalString, "20120101T010101");
+      equal(result[0].interval.end.icalString, "20120102T010101");
+      equal(result[0].freeBusyType, Ci.calIFreeBusyInterval.BUSY);
+
+      equal(result.length, 1);
+      ok(provider2.called);
+      do_test_finished();
+    },
+  };
+
+  do_test_pending();
+  freebusy.getFreeBusyIntervals(
+    "email",
+    cal.createDateTime("20120101T010101"),
+    cal.createDateTime("20120102T010101"),
+    Ci.calIFreeBusyInterval.BUSY_ALL,
+    listener
+  );
+}
+
+function test_noproviders() {
+  _clearProviders();
+
+  let listener = {
+    onResult(request, result) {
+      ok(!this.called);
+      equal(result.length, 0);
+      equal(request.status, 0);
+      do_test_finished();
+    },
+  };
+
+  do_test_pending();
+  freebusy.getFreeBusyIntervals(
+    "email",
+    cal.createDateTime("20120101T010101"),
+    cal.createDateTime("20120102T010101"),
+    Ci.calIFreeBusyInterval.BUSY_ALL,
+    listener
+  );
+}
+
+function test_failure() {
+  _clearProviders();
+
+  let provider = {
+    called: false,
+    getFreeBusyIntervals(aCalId, aStart, aEnd, aTypes, aListener) {
+      ok(!this.called);
+      this.called = true;
+      aListener.onResult({ status: Cr.NS_ERROR_FAILURE }, "notFound");
+    },
+  };
+
+  let listener = {
+    onResult(request, result) {
+      ok(!this.called);
+      equal(result.length, 0);
+      equal(request.status, 0);
+      ok(provider.called);
+      do_test_finished();
+    },
+  };
+
+  freebusy.addProvider(provider);
+
+  do_test_pending();
+  freebusy.getFreeBusyIntervals(
+    "email",
+    cal.createDateTime("20120101T010101"),
+    cal.createDateTime("20120102T010101"),
+    Ci.calIFreeBusyInterval.BUSY_ALL,
+    listener
+  );
+}
+
+function test_cancel() {
+  _clearProviders();
+
+  let provider = {
+    QueryInterface: ChromeUtils.generateQI(["calIFreeBusyProvider", "calIOperation"]),
+    getFreeBusyIntervals(aCalId, aStart, aEnd, aTypes, aListener) {
+      Services.tm.currentThread.dispatch(
+        {
+          run() {
+            dump("Cancelling freebusy query...");
+            operation.cancel();
+          },
+        },
+        Ci.nsIEventTarget.DISPATCH_NORMAL
+      );
+
+      // No listener call, we emulate a long running search
+      // Do return the operation though
+      return this;
+    },
+
+    isPending: true,
+    cancelCalled: false,
+    status: Cr.NS_OK,
+    cancel() {
+      this.cancelCalled = true;
+    },
+  };
+
+  let listener = {
+    called: false,
+    onResult(request, result) {
+      equal(result, null);
+
+      // If an exception occurs, the operation is not added to the opgroup
+      ok(!provider.cancelCalled);
+      do_test_finished();
+    },
+  };
+
+  freebusy.addProvider(provider);
+
+  do_test_pending();
+  let operation = freebusy.getFreeBusyIntervals(
+    "email",
+    cal.createDateTime("20120101T010101"),
+    cal.createDateTime("20120102T010101"),
+    Ci.calIFreeBusyInterval.BUSY_ALL,
+    listener
+  );
+}
+
+// The following functions are not in the interface description and probably
+// don't need to be. Make assumptions about the implementation instead.
+
+function _clearProviders() {
+  freebusy.wrappedJSObject.mProviders = new Set();
+}
+
+function _countProviders() {
+  return freebusy.wrappedJSObject.mProviders.size;
+}
+
+function _getFirstProvider() {
+  return [...freebusy.wrappedJSObject.mProviders][0].wrappedJSObject;
+}
diff --git a/comm/calendar/test/unit/test_hashedarray.js b/comm/calendar/test/unit/test_hashedarray.js
new file mode 100644
index 0000000000..bd1fae68ad
--- /dev/null
+++ b/comm/calendar/test/unit/test_hashedarray.js
@@ -0,0 +1,210 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calHashedArray.jsm");
+var { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+function run_test() {
+  test_array_base();
+  test_array_sorted();
+  test_hashAccessor();
+}
+
+/**
+ * Helper function to create an item that has a sensible hash id, with the given
+ * title identification.
+ *
+ * @param ident     The title to identify the item.
+ * @returns The created item.
+ */
+function hashedCreateItem(ident) {
+  let item = new CalEvent();
+  item.calendar = { id: "test" };
+  item.id = cal.getUUID();
+  item.title = ident;
+  return item;
+}
+
+/**
+ * Comparator function to sort the items by their title
+ *
+ * @param a         Object to compare.
+ * @param b         Object to compare with.
+ * @returns 0, -1, or 1 (usual comptor meanings)
+ */
+function titleComptor(a, b) {
+  if (a.title > b.title) {
+    return 1;
+  } else if (a.title < b.title) {
+    return -1;
+  }
+  return 0;
+}
+
+/**
+ * Checks if the hashed array accessor functions work for the status of the
+ * items array.
+ *
+ * @param har           The Hashed Array
+ * @param testItems     The array of test items
+ * @param itemAccessor  The accessor func to retrieve the items
+ * @throws Exception    If the arrays are not the same.
+ */
+function checkConsistancy(har, testItems, itemAccessor) {
+  itemAccessor =
+    itemAccessor ||
+    function (item) {
+      return item;
+    };
+  for (let idx in testItems) {
+    let testItem = itemAccessor(testItems[idx]);
+    equal(itemAccessor(har.itemByIndex(idx)).title, testItem.title);
+    equal(itemAccessor(har.itemById(testItem.hashId)).title, testItem.title);
+    equal(har.indexOf(testItems[idx]), idx);
+  }
+}
+
+/**
+ * Man, this function is really hard to keep general enough, I'm almost tempted
+ * to duplicate the code. It checks if the remove and modify operations work for
+ * the given hashed array.
+ *
+ * @param har               The Hashed Array
+ * @param testItems         The js array with the items
+ * @param postprocessFunc   (optional) The function to call after each
+ *                            operation, but before checking consistency.
+ * @param itemAccessor      (optional) The function to access the item for an
+ *                            array element.
+ * @param itemCreator       (optional) Function to create a new item for the
+ *                            array.
+ */
+function testRemoveModify(har, testItems, postprocessFunc, itemAccessor, itemCreator) {
+  postprocessFunc =
+    postprocessFunc ||
+    function (a, b) {
+      return [a, b];
+    };
+  itemCreator = itemCreator || (title => hashedCreateItem(title));
+  itemAccessor =
+    itemAccessor ||
+    function (item) {
+      return item;
+    };
+
+  // Now, delete the second item and check again
+  har.removeById(itemAccessor(testItems[1]).hashId);
+  testItems.splice(1, 1);
+  [har, testItems] = postprocessFunc(har, testItems);
+
+  checkConsistancy(har, testItems, itemAccessor);
+
+  // Try the same by index
+  har.removeByIndex(2);
+  testItems.splice(2, 1);
+  [har, testItems] = postprocessFunc(har, testItems);
+  checkConsistancy(har, testItems, itemAccessor);
+
+  // Try modifying an item
+  let newInstance = itemCreator("z-changed");
+  itemAccessor(newInstance).id = itemAccessor(testItems[0]).id;
+  testItems[0] = newInstance;
+  har.modifyItem(newInstance);
+  [har, testItems] = postprocessFunc(har, testItems);
+  checkConsistancy(har, testItems, itemAccessor);
+}
+
+/**
+ * Tests the basic cal.HashedArray
+ */
+function test_array_base() {
+  let har, testItems;
+
+  // Test normal additions
+  har = new cal.HashedArray();
+  testItems = ["a", "b", "c", "d"].map(hashedCreateItem);
+
+  testItems.forEach(har.addItem, har);
+  checkConsistancy(har, testItems);
+  testRemoveModify(har, testItems);
+
+  // Test adding in batch mode
+  har = new cal.HashedArray();
+  testItems = ["e", "f", "g", "h"].map(hashedCreateItem);
+  har.startBatch();
+  testItems.forEach(har.addItem, har);
+  har.endBatch();
+  checkConsistancy(har, testItems);
+  testRemoveModify(har, testItems);
+}
+
+/**
+ * Tests the sorted cal.SortedHashedArray
+ */
+function test_array_sorted() {
+  let har, testItems, testItemsSorted;
+
+  function sortedPostProcess(harParam, tiParam) {
+    tiParam = tiParam.sort(titleComptor);
+    return [harParam, tiParam];
+  }
+
+  // Test normal additions
+  har = new cal.SortedHashedArray(titleComptor);
+  testItems = ["d", "c", "a", "b"].map(hashedCreateItem);
+  testItemsSorted = testItems.sort(titleComptor);
+
+  testItems.forEach(har.addItem, har);
+  checkConsistancy(har, testItemsSorted);
+  testRemoveModify(har, testItemsSorted, sortedPostProcess);
+
+  // Test adding in batch mode
+  har = new cal.SortedHashedArray(titleComptor);
+  testItems = ["e", "f", "g", "h"].map(hashedCreateItem);
+  testItemsSorted = testItems.sort(titleComptor);
+  har.startBatch();
+  testItems.forEach(har.addItem, har);
+  har.endBatch();
+  checkConsistancy(har, testItemsSorted);
+  testRemoveModify(har, testItemsSorted, sortedPostProcess);
+}
+
+/**
+ * Tests cal.SortedHashedArray with a custom hashAccessor.
+ */
+function test_hashAccessor() {
+  let har, testItems, testItemsSorted;
+  let comptor = (a, b) => titleComptor(a.item, b.item);
+
+  har = new cal.SortedHashedArray(comptor);
+  har.hashAccessor = function (obj) {
+    return obj.item.hashId;
+  };
+
+  function itemAccessor(obj) {
+    if (!obj) {
+      do_throw("WTF?");
+    }
+    return obj.item;
+  }
+
+  function itemCreator(title) {
+    return { item: hashedCreateItem(title) };
+  }
+
+  function sortedPostProcess(harParam, tiParam) {
+    tiParam = tiParam.sort(comptor);
+    return [harParam, tiParam];
+  }
+
+  testItems = ["d", "c", "a", "b"].map(itemCreator);
+
+  testItemsSorted = testItems.sort(comptor);
+  testItems.forEach(har.addItem, har);
+  checkConsistancy(har, testItemsSorted, itemAccessor);
+  testRemoveModify(har, testItemsSorted, sortedPostProcess, itemAccessor, itemCreator);
+}
diff --git a/comm/calendar/test/unit/test_ics.js b/comm/calendar/test/unit/test_ics.js
new file mode 100644
index 0000000000..e63361fc35
--- /dev/null
+++ b/comm/calendar/test/unit/test_ics.js
@@ -0,0 +1,235 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAttachment: "resource:///modules/CalAttachment.jsm",
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalRelation: "resource:///modules/CalRelation.jsm",
+  CalTodo: "resource:///modules/CalTodo.jsm",
+});
+
+function run_test() {
+  test_folding();
+  test_icalProps();
+  test_roundtrip();
+  test_duration();
+  test_serialize();
+}
+
+var test_data = [
+  {
+    expectedDateProps: {
+      month: 10,
+      day: 25,
+      year: 2004,
+      isDate: true,
+    },
+    expectedProps: {
+      title: "Christmas",
+      id: "20041119T052239Z-1000472-1-5c0746bb-Oracle",
+      priority: 0,
+      status: "CONFIRMED",
+    },
+    ics:
+      "BEGIN:VCALENDAR\n" +
+      "PRODID:-//ORACLE//NONSGML CSDK 9.0.5 - CalDAVServlet 9.0.5//EN\n" +
+      "VERSION:2.0\n" +
+      "BEGIN:VEVENT\n" +
+      "UID:20041119T052239Z-1000472-1-5c0746bb-Oracle\n" +
+      "ORGANIZER;X-ORACLE-GUID=E9359406791C763EE0305794071A39A4;CN=Simon Vaillan\n" +
+      " court:mailto:simon.vaillancourt@oracle.com\n" +
+      "SEQUENCE:0\n" +
+      "DTSTAMP:20041124T010028Z\n" +
+      "CREATED:20041119T052239Z\n" +
+      "X-ORACLE-EVENTINSTANCE-GUID:I1+16778354+1+1+438153759\n" +
+      "X-ORACLE-EVENT-GUID:E1+16778354+1+438153759\n" +
+      "X-ORACLE-EVENTTYPE:DAY EVENT\n" +
+      "TRANSP:TRANSPARENT\n" +
+      "SUMMARY:Christmas\n" +
+      "STATUS:CONFIRMED\n" +
+      "PRIORITY:0\n" +
+      "DTSTART;VALUE=DATE:20041125\n" +
+      "DTEND;VALUE=DATE:20041125\n" +
+      "CLASS:PUBLIC\n" +
+      "ATTENDEE;X-ORACLE-GUID=E92F51FB4A48E91CE0305794071A149C;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=James Stevens;PARTSTAT=NEEDS-ACTION:mailto:james.stevens@o\n" +
+      " racle.com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E9359406791C763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=FALSE;CN=Simon Vaillancourt;PARTSTAT=ACCEPTED:mailto:simon.vaillan\n" +
+      " court@oracle.com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E9359406791D763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=Bernard Desruisseaux;PARTSTAT=NEEDS-ACTION:mailto:bernard.\n" +
+      " desruisseaux@oracle.com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E9359406791E763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=Mario Bonin;PARTSTAT=NEEDS-ACTION:mailto:mario.bonin@oracl\n" +
+      " e.com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E9359406791F763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=Jeremy Chone;PARTSTAT=NEEDS-ACTION:mailto:jeremy.chone@ora\n" +
+      " cle.com\n" +
+      "ATTENDEE;X-ORACLE-PERSONAL-COMMENT-ISDIRTY=TRUE;X-ORACLE-GUID=E9359406792\n" +
+      " 0763EE0305794071A39A4;CUTYPE=INDIVIDUAL;RSVP=TRUE;CN=Mike Shaver;PARTSTA\n" +
+      " T=NEEDS-ACTION:mailto:mike.x.shaver@oracle.com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E93594067921763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=David Ball;PARTSTAT=NEEDS-ACTION:mailto:david.ball@oracle.\n" +
+      " com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E93594067922763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=Marten Haring;PARTSTAT=NEEDS-ACTION:mailto:marten.den.hari\n" +
+      " ng@oracle.com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E93594067923763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=Peter Egyed;PARTSTAT=NEEDS-ACTION:mailto:peter.egyed@oracl\n" +
+      " e.com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E93594067924763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=Francois Perrault;PARTSTAT=NEEDS-ACTION:mailto:francois.pe\n" +
+      " rrault@oracle.com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E93594067925763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=Vladimir Vukicevic;PARTSTAT=NEEDS-ACTION:mailto:vladimir.v\n" +
+      " ukicevic@oracle.com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E93594067926763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=Cyrus Daboo;PARTSTAT=NEEDS-ACTION:mailto:daboo@isamet.com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E93594067927763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=Lisa Dusseault;PARTSTAT=NEEDS-ACTION:mailto:lisa@osafounda\n" +
+      " tion.org\n" +
+      "ATTENDEE;X-ORACLE-GUID=E93594067928763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=Dan Mosedale;PARTSTAT=NEEDS-ACTION:mailto:dan.mosedale@ora\n" +
+      " cle.com\n" +
+      "ATTENDEE;X-ORACLE-GUID=E93594067929763EE0305794071A39A4;CUTYPE=INDIVIDUAL\n" +
+      " ;RSVP=TRUE;CN=Stuart Parmenter;PARTSTAT=NEEDS-ACTION:mailto:stuart.parme\n" +
+      " nter@oracle.com\n" +
+      "END:VEVENT\n" +
+      "END:VCALENDAR\n",
+  },
+  {
+    expectedProps: { "x-magic": "mymagicstring" },
+    ics:
+      "BEGIN:VEVENT\n" +
+      "UID:1\n" +
+      "DTSTART:20070521T100000Z\n" +
+      "X-MAGIC:mymagicstring\n" +
+      "END:VEVENT",
+  },
+];
+
+function test_roundtrip() {
+  function checkEvent(data, event) {
+    checkRoundtrip(data.expectedProps, event);
+
+    // Checking dates
+    if ("expectedDateProps" in data) {
+      checkProps(data.expectedDateProps, event.startDate);
+      checkProps(data.expectedDateProps, event.endDate);
+    }
+  }
+
+  for (let data of test_data) {
+    // First round, use the icalString setter which uses synchronous parsing
+    dump("Checking" + data.ics + "\n");
+    let event = createEventFromIcalString(data.ics);
+    checkEvent(data, event);
+
+    // Now, try the same thing with asynchronous parsing. We need a copy of
+    // the data variable, otherwise javascript will mix the data between
+    // foreach loop iterations.
+    do_test_pending();
+    let thisdata = data;
+    cal.icsService.parseICSAsync(data.ics, {
+      onParsingComplete(rc, rootComp) {
+        try {
+          ok(Components.isSuccessCode(rc));
+          let event2 = new CalEvent();
+          event2.icalComponent = rootComp;
+          checkEvent(thisdata, event2);
+          do_test_finished();
+        } catch (e) {
+          do_throw(e + "\n");
+          do_test_finished();
+        }
+      },
+    });
+  }
+}
+
+function test_folding() {
+  // check folding
+  const id =
+    "loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong-id-provoking-folding";
+  let todo = new CalTodo(),
+    todo_ = new CalTodo();
+  todo.id = id;
+  todo_.icalString = todo.icalString;
+  equal(todo.id, todo_.id);
+  equal(todo_.icalComponent.getFirstProperty("UID").value, id);
+}
+
+function test_icalProps() {
+  checkIcalProp("ATTACH", new CalAttachment());
+  checkIcalProp("ATTENDEE", new CalAttendee());
+  checkIcalProp("RELATED-TO", new CalRelation());
+}
+
+/*
+ * Helper functions
+ */
+
+function checkIcalProp(aPropName, aObj) {
+  let prop1 = cal.icsService.createIcalProperty(aPropName);
+  let prop2 = cal.icsService.createIcalProperty(aPropName);
+  prop1.value = "foo";
+  prop2.value = "bar";
+  prop1.setParameter("X-FOO", "BAR");
+
+  if (aObj.setParameter) {
+    aObj.icalProperty = prop1;
+    equal(aObj.getParameter("X-FOO"), "BAR");
+    aObj.icalProperty = prop2;
+    equal(aObj.getParameter("X-FOO"), null);
+  } else if (aObj.setProperty) {
+    aObj.icalProperty = prop1;
+    equal(aObj.getProperty("X-FOO"), "BAR");
+    aObj.icalProperty = prop2;
+    equal(aObj.getProperty("X-FOO"), null);
+  }
+}
+
+function checkProps(expectedProps, obj) {
+  for (let key in expectedProps) {
+    equal(obj[key], expectedProps[key]);
+  }
+}
+
+function checkRoundtrip(expectedProps, obj) {
+  let icsdata = obj.icalString;
+  for (let key in expectedProps) {
+    // Need translation
+    let icskey = key;
+    switch (key) {
+      case "id":
+        icskey = "uid";
+        break;
+      case "title":
+        icskey = "summary";
+        break;
+    }
+    ok(icsdata.includes(icskey.toUpperCase()));
+    ok(icsdata.includes(expectedProps[key]));
+  }
+}
+
+function test_duration() {
+  let e = new CalEvent();
+  e.startDate = cal.createDateTime();
+  e.endDate = null;
+  equal(e.duration.icalString, "PT0S");
+}
+
+function test_serialize() {
+  let e = new CalEvent();
+  let prop = cal.icsService.createIcalComponent("VTODO");
+
+  throws(() => {
+    e.icalComponent = prop;
+  }, /Illegal value/);
+}
diff --git a/comm/calendar/test/unit/test_ics_parser.js b/comm/calendar/test/unit/test_ics_parser.js
new file mode 100644
index 0000000000..cd53823935
--- /dev/null
+++ b/comm/calendar/test/unit/test_ics_parser.js
@@ -0,0 +1,220 @@
+/* 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 run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  test_roundtrip();
+  test_async();
+  test_failures();
+  test_fake_parent();
+  test_props_comps();
+  test_timezone();
+}
+
+function test_props_comps() {
+  let parser = Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser);
+  let str = [
+    "BEGIN:VCALENDAR",
+    "X-WR-CALNAME:CALNAME",
+    "BEGIN:VJOURNAL",
+    "LOCATION:BEFORE TIME",
+    "END:VJOURNAL",
+    "BEGIN:VEVENT",
+    "UID:123",
+    "END:VEVENT",
+    "END:VCALENDAR",
+  ].join("\r\n");
+  parser.parseString(str);
+
+  let props = parser.getProperties();
+  equal(props.length, 1);
+  equal(props[0].propertyName, "X-WR-CALNAME");
+  equal(props[0].value, "CALNAME");
+
+  let comps = parser.getComponents();
+  equal(comps.length, 1);
+  equal(comps[0].componentType, "VJOURNAL");
+  equal(comps[0].location, "BEFORE TIME");
+}
+
+function test_failures() {
+  let parser = Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser);
+
+  do_test_pending();
+  parser.parseString("BOGUS", {
+    onParsingComplete(rc, opparser) {
+      dump("Note: The previous error message is expected ^^\n");
+      equal(rc, Cr.NS_ERROR_FAILURE);
+      do_test_finished();
+    },
+  });
+
+  // No real error here, but there is a message...
+  parser = Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser);
+  let str = ["BEGIN:VWORLD", "BEGIN:VEVENT", "UID:123", "END:VEVENT", "END:VWORLD"].join("\r\n");
+  dump("Note: The following error message is expected:\n");
+  parser.parseString(str);
+  equal(parser.getComponents().length, 0);
+  equal(parser.getItems().length, 0);
+}
+
+function test_fake_parent() {
+  let parser = Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser);
+
+  let str = [
+    "BEGIN:VCALENDAR",
+    "BEGIN:VEVENT",
+    "UID:123",
+    "RECURRENCE-ID:20120101T010101",
+    "DTSTART:20120101T010102",
+    "LOCATION:HELL",
+    "END:VEVENT",
+    "END:VCALENDAR",
+  ].join("\r\n");
+
+  parser.parseString(str);
+
+  let items = parser.getItems();
+  equal(items.length, 1);
+  let item = items[0].QueryInterface(Ci.calIEvent);
+
+  equal(item.id, "123");
+  ok(!!item.recurrenceInfo);
+  equal(item.startDate.icalString, "20120101T010101");
+  equal(item.getProperty("X-MOZ-FAKED-MASTER"), "1");
+
+  let rinfo = item.recurrenceInfo;
+
+  equal(rinfo.countRecurrenceItems(), 1);
+  let excs = rinfo.getOccurrences(cal.createDateTime("20120101T010101"), null, 0);
+  equal(excs.length, 1);
+  let exc = excs[0].QueryInterface(Ci.calIEvent);
+  equal(exc.startDate.icalString, "20120101T010102");
+
+  equal(parser.getParentlessItems()[0], exc);
+}
+
+function test_async() {
+  let parser = Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser);
+  let str = [
+    "BEGIN:VCALENDAR",
+    "BEGIN:VTODO",
+    "UID:1",
+    "DTSTART:20120101T010101",
+    "DUE:20120101T010102",
+    "END:VTODO",
+    "BEGIN:VTODO",
+    "UID:2",
+    "DTSTART:20120101T010103",
+    "DUE:20120101T010104",
+    "END:VTODO",
+    "END:VCALENDAR",
+  ].join("\r\n");
+
+  do_test_pending();
+  parser.parseString(str, {
+    onParsingComplete(rc, opparser) {
+      let items = parser.getItems();
+      equal(items.length, 2);
+      let item = items[0];
+      ok(item.isTodo());
+
+      equal(item.entryDate.icalString, "20120101T010101");
+      equal(item.dueDate.icalString, "20120101T010102");
+
+      item = items[1];
+      ok(item.isTodo());
+
+      equal(item.entryDate.icalString, "20120101T010103");
+      equal(item.dueDate.icalString, "20120101T010104");
+
+      do_test_finished();
+    },
+  });
+}
+
+function test_timezone() {
+  // TODO
+}
+
+function test_roundtrip() {
+  let parser = Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser);
+  let serializer = Cc["@mozilla.org/calendar/ics-serializer;1"].createInstance(
+    Ci.calIIcsSerializer
+  );
+  let str = [
+    "BEGIN:VCALENDAR",
+    "PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN",
+    "VERSION:2.0",
+    "X-PROP:VAL",
+    "BEGIN:VTODO",
+    "UID:1",
+    "DTSTART:20120101T010101",
+    "DUE:20120101T010102",
+    "END:VTODO",
+    "BEGIN:VJOURNAL",
+    "LOCATION:BEFORE TIME",
+    "END:VJOURNAL",
+    "END:VCALENDAR",
+    "",
+  ].join("\r\n");
+
+  parser.parseString(str);
+
+  let items = parser.getItems();
+  serializer.addItems(items);
+
+  parser.getProperties().forEach(serializer.addProperty, serializer);
+  parser.getComponents().forEach(serializer.addComponent, serializer);
+
+  equal(
+    serializer.serializeToString().split("\r\n").sort().join("\r\n"),
+    str.split("\r\n").sort().join("\r\n")
+  );
+
+  // Test parseFromStream
+  parser = Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser);
+  let stream = serializer.serializeToInputStream();
+
+  parser.parseFromStream(stream);
+
+  items = parser.getItems();
+  let comps = parser.getComponents();
+  let props = parser.getProperties();
+  equal(items.length, 1);
+  equal(comps.length, 1);
+  equal(props.length, 1);
+
+  let everything = items[0].icalString
+    .split("\r\n")
+    .concat(comps[0].serializeToICS().split("\r\n"));
+  everything.push(props[0].icalString.split("\r\n")[0]);
+  everything.sort();
+
+  equal(everything.join("\r\n"), str.split("\r\n").concat([""]).sort().join("\r\n"));
+
+  // Test serializeToStream/parseFromStream
+  parser = Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser);
+  let pipe = Cc["@mozilla.org/pipe;1"].createInstance(Ci.nsIPipe);
+  pipe.init(true, true, 0, 0, null);
+
+  serializer.serializeToStream(pipe.outputStream);
+  parser.parseFromStream(pipe.inputStream);
+
+  items = parser.getItems();
+  comps = parser.getComponents();
+  props = parser.getProperties();
+  equal(items.length, 1);
+  equal(comps.length, 1);
+  equal(props.length, 1);
+
+  everything = items[0].icalString.split("\r\n").concat(comps[0].serializeToICS().split("\r\n"));
+  everything.push(props[0].icalString.split("\r\n")[0]);
+  everything.sort();
+
+  equal(everything.join("\r\n"), str.split("\r\n").concat([""]).sort().join("\r\n"));
+}
diff --git a/comm/calendar/test/unit/test_ics_service.js b/comm/calendar/test/unit/test_ics_service.js
new file mode 100644
index 0000000000..1b69802406
--- /dev/null
+++ b/comm/calendar/test/unit/test_ics_service.js
@@ -0,0 +1,289 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAttachment: "resource:///modules/CalAttachment.jsm",
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+  CalRelation: "resource:///modules/CalRelation.jsm",
+});
+
+function run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  test_iterator();
+  test_icalcomponent();
+  test_icsservice();
+  test_icalstring();
+  test_param();
+  test_icalproperty();
+}
+
+function test_icalstring() {
+  function checkComp(createFunc, icalString, members, properties) {
+    let thing = createFunc(icalString);
+    equal(ics_unfoldline(thing.icalString), icalString + "\r\n");
+
+    if (members) {
+      for (let k in members) {
+        equal(thing[k], members[k]);
+      }
+    }
+
+    if (properties) {
+      for (let k in properties) {
+        if ("getParameter" in thing) {
+          equal(thing.getParameter(k), properties[k]);
+        } else if ("getProperty" in thing) {
+          equal(thing.getProperty(k), properties[k]);
+        }
+      }
+    }
+    return thing;
+  }
+
+  let attach = checkComp(
+    icalString => new CalAttachment(icalString),
+    "ATTACH;ENCODING=BASE64;FMTTYPE=text/calendar;FILENAME=test.ics:http://example.com/test.ics",
+    { formatType: "text/calendar", encoding: "BASE64" },
+    { FILENAME: "test.ics" }
+  );
+  equal(attach.uri.spec, "http://example.com/test.ics");
+
+  checkComp(
+    icalString => new CalAttendee(icalString),
+    "ATTENDEE;RSVP=TRUE;CN=Name;PARTSTAT=ACCEPTED;CUTYPE=RESOURCE;ROLE=REQ-PARTICIPANT;X-THING=BAR:mailto:test@example.com",
+    {
+      id: "mailto:test@example.com",
+      commonName: "Name",
+      rsvp: "TRUE",
+      isOrganizer: false,
+      role: "REQ-PARTICIPANT",
+      participationStatus: "ACCEPTED",
+      userType: "RESOURCE",
+    },
+    { "X-THING": "BAR" }
+  );
+
+  checkComp(
+    icalString => new CalRelation(icalString),
+    "RELATED-TO;RELTYPE=SIBLING;FOO=BAR:VALUE",
+    { relType: "SIBLING", relId: "VALUE" },
+    { FOO: "BAR" }
+  );
+
+  let rrule = checkComp(
+    cal.createRecurrenceRule.bind(cal),
+    "RRULE:FREQ=WEEKLY;COUNT=5;INTERVAL=2;BYDAY=MO",
+    { count: 5, isByCount: true, type: "WEEKLY", interval: 2 }
+  );
+  equal(rrule.getComponent("BYDAY").toString(), [2].toString());
+
+  let rdate = checkComp(cal.createRecurrenceDate.bind(cal), "RDATE:20120101T000000", {
+    isNegative: false,
+  });
+  equal(rdate.date.compare(cal.createDateTime("20120101T000000")), 0);
+
+  /* TODO consider removing period support, ics throws badarg
+    let rdateperiod = checkComp(cal.createRecurrenceDate.bind(cal),
+                                "RDATE;VALUE=PERIOD;20120101T000000Z/20120102T000000Z");
+    equal(rdate.date.compare(cal.createDateTime("20120101T000000Z")), 0);
+    */
+
+  let exdate = checkComp(cal.createRecurrenceDate.bind(cal), "EXDATE:20120101T000000", {
+    isNegative: true,
+  });
+  equal(exdate.date.compare(cal.createDateTime("20120101T000000")), 0);
+}
+
+function test_icsservice() {
+  function checkProp(createFunc, icalString, members, parameters) {
+    let thing = createFunc(icalString);
+    equal(ics_unfoldline(thing.icalString), icalString + "\r\n");
+
+    for (let k in members) {
+      equal(thing[k], members[k]);
+    }
+
+    for (let k in parameters) {
+      equal(thing.getParameter(k), parameters[k]);
+    }
+    return thing;
+  }
+
+  // Test ::createIcalPropertyFromString
+  checkProp(
+    cal.icsService.createIcalPropertyFromString.bind(cal.icsService),
+    "ATTACH;ENCODING=BASE64;FMTTYPE=text/calendar;FILENAME=test.ics:http://example.com/test.ics",
+    { value: "http://example.com/test.ics", propertyName: "ATTACH" },
+    { ENCODING: "BASE64", FMTTYPE: "text/calendar", FILENAME: "test.ics" }
+  );
+
+  checkProp(
+    cal.icsService.createIcalPropertyFromString.bind(cal.icsService),
+    "DESCRIPTION:new\\nlines\\nare\\ngreat\\,eh?",
+    {
+      value: "new\nlines\nare\ngreat,eh?",
+      valueAsIcalString: "new\\nlines\\nare\\ngreat\\,eh?",
+    },
+    {}
+  );
+
+  // Test ::createIcalProperty
+  let attach2 = cal.icsService.createIcalProperty("ATTACH");
+  equal(attach2.propertyName, "ATTACH");
+  attach2.value = "http://example.com/";
+  equal(attach2.icalString, "ATTACH:http://example.com/\r\n");
+}
+
+function test_icalproperty() {
+  let comp = cal.icsService.createIcalComponent("VEVENT");
+  let prop = cal.icsService.createIcalProperty("PROP");
+  prop.value = "VAL";
+
+  comp.addProperty(prop);
+  equal(prop.parent.toString(), comp.toString());
+  equal(prop.valueAsDatetime, null);
+
+  prop = cal.icsService.createIcalProperty("DESCRIPTION");
+  prop.value = "A\nB";
+  equal(prop.value, "A\nB");
+  equal(prop.valueAsIcalString, "A\\nB");
+  equal(prop.valueAsDatetime, null);
+
+  prop = cal.icsService.createIcalProperty("DESCRIPTION");
+  prop.valueAsIcalString = "A\\nB";
+  equal(prop.value, "A\nB");
+  equal(prop.valueAsIcalString, "A\\nB");
+  equal(prop.valueAsDatetime, null);
+
+  prop = cal.icsService.createIcalProperty("DESCRIPTION");
+  prop.value = "A\\nB";
+  equal(prop.value, "A\\nB");
+  equal(prop.valueAsIcalString, "A\\\\nB");
+  equal(prop.valueAsDatetime, null);
+
+  prop = cal.icsService.createIcalProperty("GEO");
+  prop.value = "43.4913662534171;12.085559129715";
+  equal(prop.value, "43.4913662534171;12.085559129715");
+  equal(prop.valueAsIcalString, "43.4913662534171;12.085559129715");
+}
+
+function test_icalcomponent() {
+  let event = cal.icsService.createIcalComponent("VEVENT");
+  let alarm = cal.icsService.createIcalComponent("VALARM");
+  event.addSubcomponent(alarm);
+
+  // Check that the parent works and does not appear on cloned instances
+  let alarm2 = alarm.clone();
+  equal(alarm.parent.toString(), event.toString());
+  equal(alarm2.parent, null);
+
+  function check_getset(key, value) {
+    dump("Checking " + key + " = " + value + "\n");
+    event[key] = value;
+    let valuestring = value.icalString || value;
+    equal(event[key].icalString || event[key], valuestring);
+    equal(event.serializeToICS().match(new RegExp(valuestring, "g")).length, 1);
+    event[key] = value;
+    equal(event.serializeToICS().match(new RegExp(valuestring, "g")).length, 1);
+  }
+
+  let props = [
+    ["uid", "123"],
+    ["prodid", "//abc/123"],
+    ["version", "2.0"],
+    ["method", "REQUEST"],
+    ["status", "TENTATIVE"],
+    ["summary", "sum"],
+    ["description", "descr"],
+    ["location", "here"],
+    ["categories", "cat"],
+    ["URL", "url"],
+    ["priority", 5],
+    ["startTime", cal.createDateTime("20120101T010101")],
+    ["endTime", cal.createDateTime("20120101T010102")],
+    /* TODO readonly, how to set... ["duration", cal.createDuration("PT2S")], */
+    ["dueTime", cal.createDateTime("20120101T010103")],
+    ["stampTime", cal.createDateTime("20120101T010104")],
+    ["createdTime", cal.createDateTime("20120101T010105")],
+    ["completedTime", cal.createDateTime("20120101T010106")],
+    ["lastModified", cal.createDateTime("20120101T010107")],
+    ["recurrenceId", cal.createDateTime("20120101T010108")],
+  ];
+
+  for (let prop of props) {
+    check_getset(...prop);
+  }
+}
+
+function test_param() {
+  let prop = cal.icsService.createIcalProperty("DTSTART");
+  prop.value = "20120101T010101";
+  equal(prop.icalString, "DTSTART:20120101T010101\r\n");
+  prop.setParameter("VALUE", "TEXT");
+  equal(prop.icalString, "DTSTART;VALUE=TEXT:20120101T010101\r\n");
+  prop.removeParameter("VALUE");
+  equal(prop.icalString, "DTSTART:20120101T010101\r\n");
+
+  prop.setParameter("X-FOO", "BAR");
+  equal(prop.icalString, "DTSTART;X-FOO=BAR:20120101T010101\r\n");
+  prop.removeParameter("X-FOO", "BAR");
+  equal(prop.icalString, "DTSTART:20120101T010101\r\n");
+}
+
+function test_iterator() {
+  // Property iterator
+  let comp = cal.icsService.createIcalComponent("VEVENT");
+  let propNames = ["X-ONE", "X-TWO"];
+  for (let i = 0; i < propNames.length; i++) {
+    let prop = cal.icsService.createIcalProperty(propNames[i]);
+    prop.value = "" + (i + 1);
+    comp.addProperty(prop);
+  }
+
+  for (let prop = comp.getFirstProperty("ANY"); prop; prop = comp.getNextProperty("ANY")) {
+    equal(prop.propertyName, propNames.shift());
+    equal(prop.parent.toString(), comp.toString());
+  }
+  propNames = ["X-ONE", "X-TWO"];
+  for (let prop = comp.getNextProperty("ANY"); prop; prop = comp.getNextProperty("ANY")) {
+    equal(prop.propertyName, propNames.shift());
+    equal(prop.parent.toString(), comp.toString());
+  }
+
+  // Property iterator with multiple values
+  // eslint-disable-next-line no-useless-concat
+  comp = cal.icsService.parseICS("BEGIN:VEVENT\r\n" + "CATEGORIES:a,b,c\r\n" + "END:VEVENT");
+  let propValues = ["a", "b", "c"];
+  for (
+    let prop = comp.getFirstProperty("CATEGORIES");
+    prop;
+    prop = comp.getNextProperty("CATEGORIES")
+  ) {
+    equal(prop.propertyName, "CATEGORIES");
+    equal(prop.value, propValues.shift());
+    equal(prop.parent.toString(), comp.toString());
+  }
+
+  // Param iterator
+  let dtstart = cal.icsService.createIcalProperty("DTSTART");
+  let params = ["X-ONE", "X-TWO"];
+  for (let i = 0; i < params.length; i++) {
+    dtstart.setParameter(params[i], "" + (i + 1));
+  }
+
+  for (let prop = dtstart.getFirstParameterName(); prop; prop = dtstart.getNextParameterName()) {
+    equal(prop, params.shift());
+  }
+
+  // Now try again, but start with next. Should act like first
+  params = ["X-ONE", "X-TWO"];
+  for (let param = dtstart.getNextParameterName(); param; param = dtstart.getNextParameterName()) {
+    equal(param, params.shift());
+  }
+}
diff --git a/comm/calendar/test/unit/test_imip.js b/comm/calendar/test/unit/test_imip.js
new file mode 100644
index 0000000000..ba9e5f5c6b
--- /dev/null
+++ b/comm/calendar/test/unit/test_imip.js
@@ -0,0 +1,47 @@
+/* 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 { CalItipEmailTransport } = ChromeUtils.import("resource:///modules/CalItipEmailTransport.jsm");
+
+function itipItemForTest(title, seq) {
+  let itipItem = Cc["@mozilla.org/calendar/itip-item;1"].createInstance(Ci.calIItipItem);
+  itipItem.init(
+    [
+      "BEGIN:VCALENDAR",
+      "METHOD:REQUEST",
+      "BEGIN:VEVENT",
+      "SUMMARY:" + title,
+      "SEQUENCE:" + (seq || 0),
+      "END:VEVENT",
+      "END:VCALENDAR",
+    ].join("\r\n")
+  );
+  return itipItem;
+}
+
+let transport = new CalItipEmailTransport();
+
+add_task(function test_title_in_subject() {
+  Services.prefs.setBoolPref("calendar.itip.useInvitationSubjectPrefixes", false);
+  let items = transport._prepareItems(itipItemForTest("foo"));
+  equal(items.subject, "foo");
+});
+
+add_task(function test_title_in_summary() {
+  Services.prefs.setBoolPref("calendar.itip.useInvitationSubjectPrefixes", true);
+  let items = transport._prepareItems(itipItemForTest("bar"));
+  equal(items.subject, "Invitation: bar");
+});
+
+add_task(function test_updated_title_in_subject() {
+  Services.prefs.setBoolPref("calendar.itip.useInvitationSubjectPrefixes", false);
+  let items = transport._prepareItems(itipItemForTest("foo", 2));
+  equal(items.subject, "foo");
+});
+
+add_task(function test_updated_title_in_summary() {
+  Services.prefs.setBoolPref("calendar.itip.useInvitationSubjectPrefixes", true);
+  let items = transport._prepareItems(itipItemForTest("bar", 2));
+  equal(items.subject, "Updated: bar");
+});
diff --git a/comm/calendar/test/unit/test_invitationutils.js b/comm/calendar/test/unit/test_invitationutils.js
new file mode 100644
index 0000000000..223ff1a6e6
--- /dev/null
+++ b/comm/calendar/test/unit/test_invitationutils.js
@@ -0,0 +1,1654 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+var { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+});
+
+function run_test() {
+  do_calendar_startup(run_next_test);
+}
+
+// tests for calInvitationUtils.jsm
+
+// Make sure that the Europe/Berlin timezone and long datetime format is set.
+Services.prefs.setIntPref("calendar.date.format", 0);
+Services.prefs.setStringPref("calendar.timezone.local", "Europe/Berlin");
+
+/**
+ * typedef {Object} FullIcsValue
+ *
+ * @property {Object<string, string>} params - Parameters for the ics property,
+ *   mapping from the parameter name to its value. Each name should be in camel
+ *   case. For example, to set "PARTSTAT=ACCEPTED" on the "attendee" property,
+ *   use `{ partstat: "ACCEPTED" }`.
+ * @property {string} value - The property value.
+ */
+
+/**
+ * An accepted property value.
+ * typedef {(FullIcsValue|string)} IcsValue
+ */
+
+/**
+ * Get a ics string for an event.
+ *
+ * @param {Object<string, (IcsValue | IcsValue[])>} [eventProperties] - Object
+ *   used to set the event properties, mapping from the ics property name to its
+ *   value. The property name should be in camel case, so "propertyName" should
+ *   be used for the "PROPERTY-NAME" property. The value can either be a single
+ *   IcsValue, or a IcsValue array if you want more than one such property
+ *   in the event (e.g. to set several "attendee" properties). If you give an
+ *   empty value for the property, then the property will be excluded.
+ *   For the "attendee" and "organizer" properties, "mailto:" will be prefixed
+ *   to the value (unless it is empty).
+ *   For the "dtstart" and "dtend" properties, the "TZID=Europe/Berlin"
+ *   parameter will be set by default.
+ *   Some properties will have default values set if they are not specified in
+ *   the object. Note that to avoid a property with a default value, you must
+ *   pass an empty value for the property.
+ *
+ * @returns {string} - The ics string.
+ */
+function getIcs(eventProperties) {
+  // we use an unfolded ics blueprint here to make replacing of properties easier
+  let item = ["BEGIN:VCALENDAR", "PRODID:-//Google Inc//Google Calendar V1.0//EN", "VERSION:2.0"];
+
+  let eventPropertyNames = eventProperties ? Object.keys(eventProperties) : [];
+
+  // Convert camel case object property name to upper case with dashes.
+  let convertPropertyName = n => n.replace(/[A-Z]/, match => `-${match}`).toUpperCase();
+
+  let propertyToString = (name, value) => {
+    let propertyString = convertPropertyName(name);
+    let setTzid = false;
+    if (typeof value == "object") {
+      for (let paramName in value.params) {
+        if (paramName == "tzid") {
+          setTzid = true;
+        }
+        propertyString += `;${convertPropertyName(paramName)}=${value.params[paramName]}`;
+      }
+      value = value.value;
+    }
+    if (!setTzid && (name == "dtstart" || name == "dtend")) {
+      propertyString += ";TZID=Europe/Berlin";
+    }
+    if (name == "organizer" || name == "attendee") {
+      value = `mailto:${value}`;
+    }
+    return `${propertyString}:${value}`;
+  };
+
+  let appendProperty = (name, value) => {
+    if (!value) {
+      // leave out.
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach(val => item.push(propertyToString(name, val)));
+    } else {
+      item.push(propertyToString(name, value));
+    }
+  };
+
+  let appendPropertyWithDefault = (name, defaultValue) => {
+    let value = defaultValue;
+    let index = eventPropertyNames.findIndex(n => n == name);
+    if (index >= 0) {
+      value = eventProperties[name];
+      // Remove the name to show that we have already handled it.
+      eventPropertyNames.splice(index, 1);
+    }
+    appendProperty(name, value);
+  };
+
+  appendPropertyWithDefault("method", "METHOD:REQUEST");
+
+  item = item.concat([
+    "BEGIN:VTIMEZONE",
+    "TZID:Europe/Berlin",
+    "BEGIN:DAYLIGHT",
+    "TZOFFSETFROM:+0100",
+    "TZOFFSETTO:+0200",
+    "TZNAME:CEST",
+    "DTSTART:19700329T020000",
+    "RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU",
+    "END:DAYLIGHT",
+    "BEGIN:STANDARD",
+    "TZOFFSETFROM:+0200",
+    "TZOFFSETTO:+0100",
+    "TZNAME:CET",
+    "DTSTART:19701025T030000",
+    "RRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU",
+    "END:STANDARD",
+    "END:VTIMEZONE",
+    "BEGIN:VEVENT",
+  ]);
+
+  for (let [name, defaultValue] of [
+    ["created", "20150909T180909Z"],
+    ["lastModified", "20150909T181048Z"],
+    ["dtstamp", "20150909T181048Z"],
+    ["uid", "cb189fdc-ed47-4db6-a8d7-31a08802249d"],
+    ["summary", "Test Event"],
+    [
+      "organizer",
+      {
+        params: { rsvp: "TRUE", cn: "Organizer", partstat: "ACCEPTED", role: "CHAIR" },
+        value: "organizer@example.net",
+      },
+    ],
+    [
+      "attendee",
+      {
+        params: { rsvp: "TRUE", cn: "Attendee", partstat: "NEEDS-ACTION", role: "REQ-PARTICIPANT" },
+        value: "attendee@example.net",
+      },
+    ],
+    ["dtstart", "20150909T210000"],
+    ["dtend", "20150909T220000"],
+    ["sequence", "1"],
+    ["transp", "OPAQUE"],
+    ["location", "Room 1"],
+    ["description", "Let us get together"],
+    ["url", "http://www.example.com"],
+    ["attach", "http://www.example.com"],
+  ]) {
+    appendPropertyWithDefault(name, defaultValue);
+  }
+
+  // Add other properties with no default.
+  for (let name of eventPropertyNames) {
+    appendProperty(name, eventProperties[name]);
+  }
+
+  item.push("END:VEVENT");
+  item.push("END:VCALENDAR");
+
+  return item.join("\r\n");
+}
+
+function getEvent(eventProperties) {
+  let item = getIcs(eventProperties);
+  let itipItem = Cc["@mozilla.org/calendar/itip-item;1"].createInstance(Ci.calIItipItem);
+  itipItem.init(item);
+  let parser = Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser);
+  parser.parseString(item);
+  return { event: parser.getItems()[0], itipItem };
+}
+
+add_task(async function getItipHeader_test() {
+  let data = [
+    {
+      name: "Organizer sends invite",
+      input: {
+        method: "REQUEST",
+        attendee: "",
+      },
+      expected: "Organizer has invited you to Test Event",
+    },
+    {
+      name: "Organizer cancels event",
+      input: {
+        method: "CANCEL",
+        attendee: "",
+      },
+      expected: "Organizer has canceled this event: Test Event",
+    },
+    {
+      name: "Organizer declines counter proposal",
+      input: {
+        method: "DECLINECOUNTER",
+        attendee: {
+          params: { rsvp: "TRUE", cn: "Attendee1", partstat: "ACCEPTED", role: "REQ-PARTICIPANT" },
+          value: "attendee1@example.net",
+        },
+      },
+      expected: 'Organizer has declined your counterproposal for "Test Event".',
+    },
+    {
+      name: "Attendee makes counter proposal",
+      input: {
+        method: "COUNTER",
+        attendee: {
+          params: { rsvp: "TRUE", cn: "Attendee1", partstat: "DECLINED", role: "REQ-PARTICIPANT" },
+          value: "attendee1@example.net",
+        },
+      },
+      expected: 'Attendee1 <attendee1@example.net> has made a counterproposal for "Test Event":',
+    },
+    {
+      name: "Attendee replies with acceptance",
+      input: {
+        method: "REPLY",
+        attendee: {
+          params: { rsvp: "TRUE", cn: "Attendee1", partstat: "ACCEPTED", role: "REQ-PARTICIPANT" },
+          value: "attendee1@example.net",
+        },
+      },
+      expected: "Attendee1 <attendee1@example.net> has accepted your event invitation.",
+    },
+    {
+      name: "Attendee replies with tentative acceptance",
+      input: {
+        method: "REPLY",
+        attendee: {
+          params: { rsvp: "TRUE", cn: "Attendee1", partstat: "TENTATIVE", role: "REQ-PARTICIPANT" },
+          value: "attendee1@example.net",
+        },
+      },
+      expected: "Attendee1 <attendee1@example.net> has accepted your event invitation.",
+    },
+    {
+      name: "Attendee replies with declined",
+      input: {
+        method: "REPLY",
+        attendee: {
+          params: { rsvp: "TRUE", cn: "Attendee1", partstat: "DECLINED", role: "REQ-PARTICIPANT" },
+          value: "attendee1@example.net",
+        },
+      },
+      expected: "Attendee1 <attendee1@example.net> has declined your event invitation.",
+    },
+    {
+      name: "Attendee1 accepts and Attendee2 declines",
+      input: {
+        method: "REPLY",
+        attendee: [
+          {
+            params: {
+              rsvp: "TRUE",
+              cn: "Attendee1",
+              partstat: "ACCEPTED",
+              role: "REQ-PARTICIPANT",
+            },
+            value: "attendee1@example.net",
+          },
+          {
+            params: {
+              rsvp: "TRUE",
+              cn: "Attendee2",
+              partstat: "DECLINED",
+              role: "REQ-PARTICIPANT",
+            },
+            value: "attendee2@example.net",
+          },
+        ],
+      },
+      expected: "Attendee1 <attendee1@example.net> has accepted your event invitation.",
+    },
+    {
+      name: "Unsupported method",
+      input: {
+        method: "UNSUPPORTED",
+        attendee: "",
+      },
+      expected: "Event Invitation",
+    },
+    {
+      name: "No method",
+      input: {
+        method: "",
+        attendee: "",
+      },
+      expected: "Event Invitation",
+    },
+  ];
+  for (let test of data) {
+    let itipItem = Cc["@mozilla.org/calendar/itip-item;1"].createInstance(Ci.calIItipItem);
+    let item = getIcs(test.input);
+    itipItem.init(item);
+    if (test.input.attendee) {
+      let sender = new CalAttendee();
+      sender.icalString = item.match(/^ATTENDEE.*$/m)[0];
+      itipItem.sender = sender.id;
+    }
+    equal(cal.invitation.getItipHeader(itipItem), test.expected, `(test ${test.name})`);
+  }
+});
+
+function assertHiddenRow(node, hidden, testName) {
+  let row = node.closest("tr");
+  ok(row, `Row above ${node.id} should exist (test ${testName})`);
+  if (hidden) {
+    equal(
+      node.textContent,
+      "",
+      `Node ${node.id} should be empty below a hidden row (test ${testName})`
+    );
+    ok(row.hidden, `Row above ${node.id} should be hidden (test ${testName})`);
+  } else {
+    ok(!row.hidden, `Row above ${node.id} should not be hidden (test ${testName})`);
+  }
+}
+
+add_task(async function createInvitationOverlay_test() {
+  let data = [
+    {
+      name: "No description",
+      input: { description: "" },
+      expected: { node: "imipHtml-description-content", hidden: true },
+    },
+    {
+      name: "Description with https link",
+      input: { description: "Go to https://www.example.net if you can." },
+      expected: {
+        node: "imipHtml-description-content",
+        content:
+          'Go to <a class="moz-txt-link-freetext" href="https://www.example.net">' +
+          "https://www.example.net</a> if you can.",
+      },
+    },
+    {
+      name: "Description plain link",
+      input: { description: "Go to www.example.net if you can." },
+      expected: {
+        node: "imipHtml-description-content",
+        content:
+          'Go to <a class="moz-txt-link-abbreviated" href="http://www.example.net">' +
+          "www.example.net</a> if you can.",
+      },
+    },
+    {
+      name: "Description with +/-",
+      input: { description: "Let's see if +/- still can be displayed." },
+      expected: {
+        node: "imipHtml-description-content",
+        content: "Let's see if +/- still can be displayed.",
+      },
+    },
+    {
+      name: "Description with mailto",
+      input: { description: "Or write to mailto:faq@example.net instead." },
+      expected: {
+        node: "imipHtml-description-content",
+        content:
+          'Or write to <a class="moz-txt-link-freetext" ' +
+          'href="mailto:faq@example.net">mailto:faq@example.net</a> instead.',
+      },
+    },
+    {
+      name: "Description with email",
+      input: { description: "Or write to faq@example.net instead." },
+      expected: {
+        node: "imipHtml-description-content",
+        content:
+          'Or write to <a class="moz-txt-link-abbreviated" ' +
+          'href="mailto:faq@example.net">faq@example.net</a> instead.',
+      },
+    },
+    {
+      name: "Description with emoticon",
+      input: { description: "It's up to you ;-)" },
+      expected: {
+        node: "imipHtml-description-content",
+        content: "It's up to you ;-)",
+      },
+    },
+    {
+      name: "Removed script injection from description",
+      input: {
+        description:
+          'Let\'s see how evil we can be: <script language="JavaScript">' +
+          'document.getElementById("imipHtml-description-content")' +
+          '.write("Script embedded!")</script>',
+      },
+      expected: {
+        node: "imipHtml-description-content",
+        content: "Let's see how evil we can be: ",
+      },
+    },
+    {
+      name: "Removed img src injection from description",
+      input: {
+        description:
+          'Or we can try: <img src="document.getElementById("imipHtml-' +
+          'description-descr").innerText" >',
+      },
+      expected: {
+        node: "imipHtml-description-content",
+        content: "Or we can try: ",
+      },
+    },
+    {
+      name: "Description with special characters",
+      input: {
+        description:
+          'Check <a href="http://example.com">example.com</a>&nbsp;&nbsp;&mdash; only 3 &euro;',
+      },
+      expected: {
+        node: "imipHtml-description-content",
+        content: 'Check <a href="http://example.com">example.com</a>&nbsp;&nbsp;— only 3 €',
+      },
+    },
+    {
+      name: "URL",
+      input: { url: "http://www.example.org/event.ics" },
+      expected: {
+        node: "imipHtml-url-content",
+        content:
+          '<a class="moz-txt-link-freetext" href="http://www.example.org/event.ics">' +
+          "http://www.example.org/event.ics</a>",
+      },
+    },
+    {
+      name: "URL attachment",
+      input: { attach: "http://www.example.org" },
+      expected: {
+        node: "imipHtml-attachments-content",
+        content:
+          '<a class="moz-txt-link-freetext" href="http://www.example.org/">' +
+          "http://www.example.org/</a>",
+      },
+    },
+    {
+      name: "Non-URL attachment is ignored",
+      input: {
+        attach: {
+          params: { fmttype: "text/plain", encoding: "BASE64", value: "BINARY" },
+          value: "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZy4",
+        },
+      },
+      expected: { node: "imipHtml-attachments-content", hidden: true },
+    },
+    {
+      name: "Several attachments",
+      input: {
+        attach: [
+          "http://www.example.org/first/",
+          "http://www.example.org/second",
+          "file:///N:/folder/third.file",
+        ],
+      },
+      expected: {
+        node: "imipHtml-attachments-content",
+        content:
+          '<a class="moz-txt-link-freetext" href="http://www.example.org/first/">' +
+          "http://www.example.org/first/</a><br>" +
+          '<a class="moz-txt-link-freetext" href="http://www.example.org/second">' +
+          "http://www.example.org/second</a><br>" +
+          '<a class="moz-txt-link-freetext">file:///N:/folder/third.file</a>',
+      },
+    },
+    {
+      name: "Attendees",
+      input: {
+        attendee: [
+          {
+            params: {
+              rsvp: "TRUE",
+              partstat: "NEEDS-ACTION",
+              role: "OPT-PARTICIPANT",
+              cutype: "INDIVIDUAL",
+              cn: '"Attendee 1"',
+            },
+            value: "attendee1@example.net",
+          },
+          {
+            params: {
+              rsvp: "TRUE",
+              partstat: "ACCEPTED",
+              role: "NON-PARTICIPANT",
+              cutype: "GROUP",
+            },
+            value: "attendee2@example.net",
+          },
+          {
+            params: {
+              rsvp: "TRUE",
+              partstat: "TENTATIVE",
+              role: "REQ-PARTICIPANT",
+              cutype: "RESOURCE",
+            },
+            value: "attendee3@example.net",
+          },
+          {
+            params: {
+              rsvp: "TRUE",
+              partstat: "DECLINED",
+              role: "OPT-PARTICIPANT",
+              delegatedFrom: '"mailto:attendee5@example.net"',
+              cutype: "ROOM",
+            },
+            value: "attendee4@example.net",
+          },
+          {
+            params: {
+              rsvp: "TRUE",
+              partstat: "DELEGATED",
+              role: "OPT-PARTICIPANT",
+              delegatedTo: '"mailto:attendee4@example.net"',
+              cutype: "UNKNOWN",
+            },
+            value: "attendee5@example.net",
+          },
+          {
+            params: { rsvp: "TRUE" },
+            value: "attendee6@example.net",
+          },
+          "attendee7@example.net",
+        ],
+      },
+      expected: {
+        node: "imipHtml-attendees-cell",
+        attendeesList: [
+          {
+            name: "Attendee 1 <attendee1@example.net>",
+            title:
+              "Attendee 1 <attendee1@example.net> is an optional " +
+              "participant. Attendee 1 still needs to reply.",
+            icon: {
+              attendeerole: "OPT-PARTICIPANT",
+              usertype: "INDIVIDUAL",
+              partstat: "NEEDS-ACTION",
+            },
+          },
+          {
+            name: "attendee2@example.net",
+            title:
+              "attendee2@example.net (group) is a non-participant. " +
+              "attendee2@example.net has confirmed attendance.",
+            icon: {
+              attendeerole: "NON-PARTICIPANT",
+              usertype: "GROUP",
+              partstat: "ACCEPTED",
+            },
+          },
+          {
+            name: "attendee3@example.net",
+            title:
+              "attendee3@example.net (resource) is a required " +
+              "participant. attendee3@example.net has confirmed attendance " +
+              "tentatively.",
+            icon: {
+              attendeerole: "REQ-PARTICIPANT",
+              usertype: "RESOURCE",
+              partstat: "TENTATIVE",
+            },
+          },
+          {
+            name: "attendee4@example.net (delegated from attendee5@example.net)",
+            title:
+              "attendee4@example.net (room) is an optional participant. " +
+              "attendee4@example.net has declined attendance.",
+            icon: {
+              attendeerole: "OPT-PARTICIPANT",
+              usertype: "ROOM",
+              partstat: "DECLINED",
+            },
+          },
+          {
+            name: "attendee5@example.net",
+            title:
+              "attendee5@example.net is an optional participant. " +
+              "attendee5@example.net has delegated attendance to " +
+              "attendee4@example.net.",
+            icon: {
+              attendeerole: "OPT-PARTICIPANT",
+              usertype: "UNKNOWN",
+              partstat: "DELEGATED",
+            },
+          },
+          {
+            name: "attendee6@example.net",
+            title:
+              "attendee6@example.net is a required participant. " +
+              "attendee6@example.net still needs to reply.",
+            icon: {
+              attendeerole: "REQ-PARTICIPANT",
+              usertype: "INDIVIDUAL",
+              partstat: "NEEDS-ACTION",
+            },
+          },
+          {
+            name: "attendee7@example.net",
+            title:
+              "attendee7@example.net is a required participant. " +
+              "attendee7@example.net still needs to reply.",
+            icon: {
+              attendeerole: "REQ-PARTICIPANT",
+              usertype: "INDIVIDUAL",
+              partstat: "NEEDS-ACTION",
+            },
+          },
+        ],
+      },
+    },
+    {
+      name: "Organizer",
+      input: {
+        organizer: {
+          params: {
+            partstat: "ACCEPTED",
+            role: "CHAIR",
+            cutype: "INDIVIDUAL",
+            cn: '"The Organizer"',
+          },
+          value: "organizer@example.net",
+        },
+      },
+      expected: {
+        node: "imipHtml-organizer-cell",
+        organizer: {
+          name: "The Organizer <organizer@example.net>",
+          title:
+            "The Organizer <organizer@example.net> chairs the event. " +
+            "The Organizer has confirmed attendance.",
+          icon: {
+            attendeerole: "CHAIR",
+            usertype: "INDIVIDUAL",
+            partstat: "ACCEPTED",
+          },
+        },
+      },
+    },
+  ];
+
+  function assertAttendee(attendee, name, title, icon, testName) {
+    equal(attendee.textContent, name, `Attendee names (test ${testName})`);
+    equal(attendee.getAttribute("title"), title, `Title for ${name} (test ${testName})`);
+    let attendeeIcon = attendee.querySelector(".itip-icon");
+    ok(attendeeIcon, `icon for ${name} should exist (test ${testName})`);
+    for (let attr in icon) {
+      equal(
+        attendeeIcon.getAttribute(attr),
+        icon[attr],
+        `${attr} for icon for ${name} (test ${testName})`
+      );
+    }
+  }
+
+  for (let test of data) {
+    info(`testing ${test.name}`);
+    let { event, itipItem } = getEvent(test.input);
+    let dom = cal.invitation.createInvitationOverlay(event, itipItem);
+    let node = dom.getElementById(test.expected.node);
+    ok(node, `Element with id ${test.expected.node} should exist (test ${test.name})`);
+    if (test.expected.hidden) {
+      assertHiddenRow(node, true, test.name);
+      continue;
+    }
+    assertHiddenRow(node, false, test.name);
+
+    if ("attendeesList" in test.expected) {
+      let attendeeNodes = node.querySelectorAll(".attendee-label");
+      // Assert same order.
+      let i;
+      for (i = 0; i < test.expected.attendeesList.length; i++) {
+        let { name, title, icon } = test.expected.attendeesList[i];
+        ok(
+          attendeeNodes.length > i,
+          `Enough attendees for expected attendee #${i} ${name} (test ${test.name})`
+        );
+        assertAttendee(attendeeNodes[i], name, title, icon, test.name);
+      }
+      equal(attendeeNodes.length, i, `Same number of attendees (test ${test.name})`);
+    } else if ("organizer" in test.expected) {
+      let { name, title, icon } = test.expected.organizer;
+      let organizerNode = node.querySelector(".attendee-label");
+      ok(organizerNode, `Organizer node should exist (test ${test.name})`);
+      assertAttendee(organizerNode, name, title, icon, test.name);
+    } else {
+      equal(node.innerHTML, test.expected.content, `innerHTML (test ${test.name})`);
+    }
+  }
+});
+
+add_task(async function updateInvitationOverlay_test() {
+  let data = [
+    {
+      name: "No description before or after",
+      input: { previous: { description: "" }, current: { description: "" } },
+      expected: { node: "imipHtml-description-content", hidden: true },
+    },
+    {
+      name: "Same description before and after",
+      input: {
+        previous: { description: "This is the description" },
+        current: { description: "This is the description" },
+      },
+      expected: {
+        node: "imipHtml-description-content",
+        content: [{ type: "same", text: "This is the description" }],
+      },
+    },
+    {
+      name: "Added description",
+      input: {
+        previous: { description: "" },
+        current: { description: "Added this description" },
+      },
+      expected: {
+        node: "imipHtml-description-content",
+        content: [{ type: "added", text: "Added this description" }],
+      },
+    },
+    {
+      name: "Removed description",
+      input: {
+        previous: { description: "Removed this description" },
+        current: { description: "" },
+      },
+      expected: {
+        node: "imipHtml-description-content",
+        content: [{ type: "removed", text: "Removed this description" }],
+      },
+    },
+    {
+      name: "Location",
+      input: {
+        previous: { location: "This place" },
+        current: { location: "Another location" },
+      },
+      expected: {
+        node: "imipHtml-location-content",
+        content: [
+          { type: "added", text: "Another location" },
+          { type: "removed", text: "This place" },
+        ],
+      },
+    },
+    {
+      name: "Summary",
+      input: {
+        previous: { summary: "My invitation" },
+        current: { summary: "My new invitation" },
+      },
+      expected: {
+        node: "imipHtml-summary-content",
+        content: [
+          { type: "added", text: "My new invitation" },
+          { type: "removed", text: "My invitation" },
+        ],
+      },
+    },
+    {
+      name: "When",
+      input: {
+        previous: {
+          dtstart: "20150909T130000",
+          dtend: "20150909T140000",
+        },
+        current: {
+          dtstart: "20150909T140000",
+          dtend: "20150909T150000",
+        },
+      },
+      expected: {
+        node: "imipHtml-when-content",
+        content: [
+          // Time format is platform dependent, so we use alternative result
+          // sets here.
+          // If you get a failure for this test, add your pattern here.
+          {
+            type: "added",
+            text: /^Wednesday, (September 0?9,|0?9 September) 2015 (2:00 PM – 3:00 PM|14:00 – 15:00)$/,
+          },
+          {
+            type: "removed",
+            text: /^Wednesday, (September 0?9,|0?9 September) 2015 (1:00 PM – 2:00 PM|13:00 – 14:00)$/,
+          },
+        ],
+      },
+    },
+    {
+      name: "Organizer same",
+      input: {
+        previous: { organizer: "organizer1@example.net" },
+        current: { organizer: "organizer1@example.net" },
+      },
+      expected: {
+        node: "imipHtml-organizer-cell",
+        organizer: [{ type: "same", text: "organizer1@example.net" }],
+      },
+    },
+    {
+      name: "Organizer modified",
+      input: {
+        // Modify ROLE from CHAIR to REQ-PARTICIPANT.
+        previous: { organizer: { params: { role: "CHAIR" }, value: "organizer1@example.net" } },
+        current: {
+          organizer: { params: { role: "REQ-PARTICIPANT" }, value: "organizer1@example.net" },
+        },
+      },
+      expected: {
+        node: "imipHtml-organizer-cell",
+        organizer: [{ type: "modified", text: "organizer1@example.net" }],
+      },
+    },
+    {
+      name: "Organizer added",
+      input: {
+        previous: { organizer: "" },
+        current: { organizer: "organizer2@example.net" },
+      },
+      expected: {
+        node: "imipHtml-organizer-cell",
+        organizer: [{ type: "added", text: "organizer2@example.net" }],
+      },
+    },
+    {
+      name: "Organizer removed",
+      input: {
+        previous: { organizer: "organizer2@example.net" },
+        current: { organizer: "" },
+      },
+      expected: {
+        node: "imipHtml-organizer-cell",
+        organizer: [{ type: "removed", text: "organizer2@example.net" }],
+      },
+    },
+    {
+      name: "Organizer changed",
+      input: {
+        previous: { organizer: "organizer1@example.net" },
+        current: { organizer: "organizer2@example.net" },
+      },
+      expected: {
+        node: "imipHtml-organizer-cell",
+        organizer: [
+          { type: "added", text: "organizer2@example.net" },
+          { type: "removed", text: "organizer1@example.net" },
+        ],
+      },
+    },
+    {
+      name: "Attendees: modify one, remove one, add one",
+      input: {
+        previous: {
+          attendee: [
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee1@example.net",
+            },
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee2@example.net",
+            },
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee3@example.net",
+            },
+          ],
+        },
+        current: {
+          attendee: [
+            {
+              // Modify PARTSTAT from NEEDS-ACTION.
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "ACCEPTED" },
+              value: "attendee2@example.net",
+            },
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee3@example.net",
+            },
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee4@example.net",
+            },
+          ],
+        },
+      },
+      expected: {
+        node: "imipHtml-attendees-cell",
+        attendeesList: [
+          { type: "removed", text: "attendee1@example.net" },
+          { type: "modified", text: "attendee2@example.net" },
+          { type: "same", text: "attendee3@example.net" },
+          { type: "added", text: "attendee4@example.net" },
+        ],
+      },
+    },
+    {
+      name: "Attendees: modify one, remove three, add two",
+      input: {
+        previous: {
+          attendee: [
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee-remove1@example.net",
+            },
+            {
+              params: { rsvp: "TRUE", cutype: "GROUP", partstat: "NEEDS-ACTION" },
+              value: "attendee1@example.net",
+            },
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee-remove2@example.net",
+            },
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee-remove3@example.net",
+            },
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee3@example.net",
+            },
+          ],
+        },
+        current: {
+          attendee: [
+            {
+              // Modify CUTYPE from GROUP.
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee1@example.net",
+            },
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee-add1@example.net",
+            },
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee-add2@example.net",
+            },
+            {
+              params: { rsvp: "TRUE", cutype: "INDIVIDUAL", partstat: "NEEDS-ACTION" },
+              value: "attendee3@example.net",
+            },
+          ],
+        },
+      },
+      expected: {
+        node: "imipHtml-attendees-cell",
+        attendeesList: [
+          { type: "removed", text: "attendee-remove1@example.net" },
+          { type: "modified", text: "attendee1@example.net" },
+          // Added shown first, then removed, and in between the common
+          // attendees.
+          { type: "added", text: "attendee-add1@example.net" },
+          { type: "added", text: "attendee-add2@example.net" },
+          { type: "removed", text: "attendee-remove2@example.net" },
+          { type: "removed", text: "attendee-remove3@example.net" },
+          { type: "same", text: "attendee3@example.net" },
+        ],
+      },
+    },
+  ];
+
+  function assertElement(node, text, type, testName) {
+    let found = node.textContent;
+    if (text instanceof RegExp) {
+      ok(text.test(found), `Text content "${found}" matches regex (test ${testName})`);
+    } else {
+      equal(text, found, `Text content matches (test ${testName})`);
+    }
+    switch (type) {
+      case "added":
+        equal(node.tagName, "INS", `Text "${text}" is inserted (test ${testName})`);
+        ok(node.classList.contains("added"), `Text "${text}" is added (test ${testName})`);
+        break;
+      case "removed":
+        equal(node.tagName, "DEL", `Text "${text}" is deleted (test ${testName})`);
+        ok(node.classList.contains("removed"), `Text "${text}" is removed (test ${testName})`);
+        break;
+      case "modified":
+        ok(node.tagName !== "DEL", `Text "${text}" is not deleted (test ${testName})`);
+        ok(node.tagName !== "INS", `Text "${text}" is not inserted (test ${testName})`);
+        ok(node.classList.contains("modified"), `Text "${text}" is modified (test ${testName})`);
+        break;
+      case "same":
+        // NOTE: node may be a Text node.
+        ok(node.tagName !== "DEL", `Text "${text}" is not deleted (test ${testName})`);
+        ok(node.tagName !== "INS", `Text "${text}" is not inserted (test ${testName})`);
+        if (node.classList) {
+          ok(!node.classList.contains("added"), `Text "${text}" is not added (test ${testName})`);
+          ok(
+            !node.classList.contains("removed"),
+            `Text "${text}" is not removed (test ${testName})`
+          );
+          ok(
+            !node.classList.contains("modified"),
+            `Text "${text}" is not modified (test ${testName})`
+          );
+        }
+        break;
+      default:
+        ok(false, `Unknown type ${type} for text "${text}" (test ${testName})`);
+        break;
+    }
+  }
+
+  for (let test of data) {
+    info(`testing ${test.name}`);
+    let { event, itipItem } = getEvent(test.input.current);
+    let dom = cal.invitation.createInvitationOverlay(event, itipItem);
+    let { event: oldEvent } = getEvent(test.input.previous);
+    cal.invitation.updateInvitationOverlay(dom, event, itipItem, oldEvent);
+
+    let node = dom.getElementById(test.expected.node);
+    ok(node, `Element with id ${test.expected.node} should exist (test ${test.name})`);
+    if (test.expected.hidden) {
+      assertHiddenRow(node, true, test.name);
+      continue;
+    }
+    assertHiddenRow(node, false, test.name);
+
+    let insertBreaks = false;
+    let nodeList;
+    let expectList;
+
+    if ("attendeesList" in test.expected) {
+      // Insertions, deletions and modifications are all within separate
+      // list-items.
+      nodeList = node.querySelectorAll(":scope > .attendee-list > .attendee-list-item > *");
+      expectList = test.expected.attendeesList;
+    } else if ("organizer" in test.expected) {
+      nodeList = node.childNodes;
+      expectList = test.expected.organizer;
+    } else {
+      nodeList = node.childNodes;
+      expectList = test.expected.content;
+      insertBreaks = true;
+    }
+
+    // Assert in same order.
+    let first = true;
+    let nodeIndex = 0;
+    for (let { text, type } of expectList) {
+      if (first) {
+        first = false;
+      } else if (insertBreaks) {
+        ok(
+          nodeList.length > nodeIndex,
+          `Enough child nodes for expected break node at index ${nodeIndex} (test ${test.name})`
+        );
+        equal(
+          nodeList[nodeIndex].tagName,
+          "BR",
+          `Break node at index ${nodeIndex} (test ${test.name})`
+        );
+        nodeIndex++;
+      }
+
+      ok(
+        nodeList.length > nodeIndex,
+        `Enough child nodes for expected node at index ${nodeIndex} "${text}" (test ${test.name})`
+      );
+      assertElement(nodeList[nodeIndex], text, type, test.name);
+      nodeIndex++;
+    }
+    equal(nodeList.length, nodeIndex, `Covered all nodes (test ${test.name})`);
+  }
+});
+
+add_task(async function getHeaderSection_test() {
+  let data = [
+    {
+      // test #1
+      input: {
+        toList: "recipient@example.net",
+        subject: "Invitation: test subject",
+        identity: {
+          fullName: "Invitation sender",
+          email: "sender@example.net",
+          replyTo: "no-reply@example.net",
+          organization: "Example Net",
+          cc: "cc@example.net",
+          bcc: "bcc@example.net",
+        },
+      },
+      expected:
+        "MIME-version: 1.0\r\n" +
+        "Return-path: no-reply@example.net\r\n" +
+        "From: Invitation sender <sender@example.net>\r\n" +
+        "Organization: Example Net\r\n" +
+        "To: recipient@example.net\r\n" +
+        "Subject: Invitation: test subject\r\n" +
+        "Cc: cc@example.net\r\n" +
+        "Bcc: bcc@example.net\r\n",
+    },
+    {
+      // test #2
+      input: {
+        toList: 'rec1@example.net, Recipient 2 <rec2@example.net>, "Rec, 3" <rec3@example.net>',
+        subject: "Invitation: test subject",
+        identity: {
+          fullName: '"invitation, sender"',
+          email: "sender@example.net",
+          replyTo: "no-reply@example.net",
+          organization: "Example Net",
+          cc: 'cc1@example.net, Cc 2 <cc2@example.net>, "Cc, 3" <cc3@example.net>',
+          bcc: 'bcc1@example.net, BCc 2 <bcc2@example.net>, "Bcc, 3" <bcc3@example.net>',
+        },
+      },
+      expected:
+        "MIME-version: 1.0\r\n" +
+        "Return-path: no-reply@example.net\r\n" +
+        'From: "invitation, sender" <sender@example.net>\r\n' +
+        "Organization: Example Net\r\n" +
+        'To: rec1@example.net, Recipient 2 <rec2@example.net>,\r\n "Rec, 3" <rec3@example.net>\r\n' +
+        "Subject: Invitation: test subject\r\n" +
+        'Cc: cc1@example.net, Cc 2 <cc2@example.net>, "Cc, 3" <cc3@example.net>\r\n' +
+        'Bcc: bcc1@example.net, BCc 2 <bcc2@example.net>, "Bcc, 3"\r\n <bcc3@example.net>\r\n',
+    },
+    {
+      // test #3
+      input: {
+        toList: "recipient@example.net",
+        subject: "Invitation: test subject",
+        identity: { email: "sender@example.net" },
+      },
+      expected:
+        "MIME-version: 1.0\r\n" +
+        "From: sender@example.net\r\n" +
+        "To: recipient@example.net\r\n" +
+        "Subject: Invitation: test subject\r\n",
+    },
+    {
+      // test #4
+      input: {
+        toList: "Max Müller <mueller@example.net>",
+        subject: "Invitation: Diacritis check (üäé)",
+        identity: {
+          fullName: "René",
+          email: "sender@example.net",
+          replyTo: "Max & René <no-reply@example.net>",
+          organization: "Max & René",
+          cc: "René <cc@example.net>",
+          bcc: "René <bcc@example.net>",
+        },
+      },
+      expected:
+        "MIME-version: 1.0\r\n" +
+        "Return-path: =?UTF-8?B?TWF4ICYgUmVuw6k=?= <no-reply@example.net>\r\n" +
+        "From: =?UTF-8?B?UmVuw6k=?= <sender@example.net>\r\n" +
+        "Organization: =?UTF-8?B?TWF4ICYgUmVuw6k=?=\r\n" +
+        "To: =?UTF-8?Q?Max_M=C3=BCller?= <mueller@example.net>\r\n" +
+        "Subject: =?UTF-8?B?SW52aXRhdGlvbjogRGlhY3JpdGlzIGNoZWNrICjDvMOk?=\r\n =?UTF-8?B" +
+        "?w6kp?=\r\n" +
+        "Cc: =?UTF-8?B?UmVuw6k=?= <cc@example.net>\r\n" +
+        "Bcc: =?UTF-8?B?UmVuw6k=?= <bcc@example.net>\r\n",
+    },
+  ];
+  let i = 0;
+  for (let test of data) {
+    i++;
+    info(`Running test #${i}`);
+    let identity = MailServices.accounts.createIdentity();
+    identity.email = test.input.identity.email || null;
+    identity.fullName = test.input.identity.fullName || null;
+    identity.replyTo = test.input.identity.replyTo || null;
+    identity.organization = test.input.identity.organization || null;
+    identity.doCc = test.input.identity.doCc || test.input.identity.cc;
+    identity.doCcList = test.input.identity.cc || null;
+    identity.doBcc = test.input.identity.doBcc || test.input.identity.bcc;
+    identity.doBccList = test.input.identity.bcc || null;
+
+    let composeUtils = Cc["@mozilla.org/messengercompose/computils;1"].createInstance(
+      Ci.nsIMsgCompUtils
+    );
+    let messageId = composeUtils.msgGenerateMessageId(identity, null);
+
+    let header = cal.invitation.getHeaderSection(
+      messageId,
+      identity,
+      test.input.toList,
+      test.input.subject
+    );
+    // we test Date and Message-ID headers separately to avoid false positives
+    ok(!!header.match(/Date:.+(?:\n|\r\n|\r)/), "(test #" + i + "): date");
+    ok(!!header.match(/Message-ID:.+(?:\n|\r\n|\r)/), "(test #" + i + "): message-id");
+    equal(
+      header.replace(/Date:.+(?:\n|\r\n|\r)/, "").replace(/Message-ID:.+(?:\n|\r\n|\r)/, ""),
+      test.expected.replace(/Date:.+(?:\n|\r\n|\r)/, "").replace(/Message-ID:.+(?:\n|\r\n|\r)/, ""),
+      "(test #" + i + "): all headers"
+    );
+  }
+});
+
+add_task(async function convertFromUnicode_test() {
+  let data = [
+    {
+      // test #1
+      input: "müller",
+      expected: "müller",
+    },
+    {
+      // test #2
+      input: "muller",
+      expected: "muller",
+    },
+    {
+      // test #3
+      input: "müller\nmüller",
+      expected: "müller\nmüller",
+    },
+    {
+      // test #4
+      input: "müller\r\nmüller",
+      expected: "müller\r\nmüller",
+    },
+  ];
+  let i = 0;
+  for (let test of data) {
+    i++;
+    equal(cal.invitation.convertFromUnicode(test.input), test.expected, "(test #" + i + ")");
+  }
+});
+
+add_task(async function encodeUTF8_test() {
+  let data = [
+    {
+      // test #1
+      input: "müller",
+      expected: "müller",
+    },
+    {
+      // test #2
+      input: "muller",
+      expected: "muller",
+    },
+    {
+      // test #3
+      input: "müller\nmüller",
+      expected: "müller\r\nmüller",
+    },
+    {
+      // test #4
+      input: "müller\r\nmüller",
+      expected: "müller\r\nmüller",
+    },
+    {
+      // test #5
+      input: "",
+      expected: "",
+    },
+  ];
+  let i = 0;
+  for (let test of data) {
+    i++;
+    equal(cal.invitation.encodeUTF8(test.input), test.expected, "(test #" + i + ")");
+  }
+});
+
+add_task(async function encodeMimeHeader_test() {
+  let data = [
+    {
+      // test #1
+      input: {
+        header: "Max Müller <m.mueller@example.net>",
+        isEmail: true,
+      },
+      expected: "=?UTF-8?Q?Max_M=C3=BCller?= <m.mueller@example.net>",
+    },
+    {
+      // test #2
+      input: {
+        header: "Max Mueller <m.mueller@example.net>",
+        isEmail: true,
+      },
+      expected: "Max Mueller <m.mueller@example.net>",
+    },
+    {
+      // test #3
+      input: {
+        header: "Müller & Müller",
+        isEmail: false,
+      },
+      expected: "=?UTF-8?B?TcO8bGxlciAmIE3DvGxsZXI=?=",
+    },
+  ];
+
+  let i = 0;
+  for (let test of data) {
+    i++;
+    equal(
+      cal.invitation.encodeMimeHeader(test.input.header, test.input.isEmail),
+      test.expected,
+      "(test #" + i + ")"
+    );
+  }
+});
+
+add_task(async function getRfc5322FormattedDate_test() {
+  let data = {
+    input: [
+      {
+        // test #1
+        date: null,
+        timezone: "America/New_York",
+      },
+      {
+        // test #2
+        date: "Sat, 24 Jan 2015 09:24:49 +0100",
+        timezone: "America/New_York",
+      },
+      {
+        // test #3
+        date: "Sat, 24 Jan 2015 09:24:49 GMT+0100",
+        timezone: "America/New_York",
+      },
+      {
+        // test #4
+        date: "Sat, 24 Jan 2015 09:24:49 GMT",
+        timezone: "America/New_York",
+      },
+      {
+        // test #5
+        date: "Sat, 24 Jan 2015 09:24:49",
+        timezone: "America/New_York",
+      },
+      {
+        // test #6
+        date: "Sat, 24 Jan 2015 09:24:49",
+        timezone: null,
+      },
+      {
+        // test #7
+        date: "Sat, 24 Jan 2015 09:24:49",
+        timezone: "UTC",
+      },
+      {
+        // test #8
+        date: "Sat, 24 Jan 2015 09:24:49",
+        timezone: "floating",
+      },
+    ],
+    expected: /^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} [+-]\d{4}$/,
+  };
+
+  let i = 0;
+  let timezone = Services.prefs.getStringPref("calendar.timezone.local", null);
+  for (let test of data.input) {
+    i++;
+    if (test.timezone) {
+      Services.prefs.setStringPref("calendar.timezone.local", test.timezone);
+    } else {
+      Services.prefs.clearUserPref("calendar.timezone.local");
+    }
+    let date = test.date ? new Date(test.date) : null;
+    let re = new RegExp(data.expected);
+    ok(re.test(cal.invitation.getRfc5322FormattedDate(date)), "(test #" + i + ")");
+  }
+  Services.prefs.setStringPref("calendar.timezone.local", timezone);
+});
+
+add_task(async function parseCounter_test() {
+  // We are disabling this rule for a more consistent display of this data
+  /* eslint-disable object-curly-newline */
+  let data = [
+    {
+      name: "Basic test to check all currently supported properties",
+      input: {
+        proposed: {
+          method: "COUNTER",
+          dtstart: "20150910T210000",
+          dtend: "20150910T220000",
+          location: "Room 2",
+          summary: "Test Event 2",
+          attendee: {
+            params: { cn: "Attendee", partstat: "DECLINED", role: "REQ-PARTICIPANT" },
+            value: "attendee@example.net",
+          },
+          dtstamp: "20150909T182048Z",
+          comment: "Sorry, I cannot make it that time.",
+        },
+      },
+      expected: {
+        // Time format is platform dependent, so we use alternative result sets here.
+        // The first two are configurations running for automated tests.
+        // If you get a failure for this test, add your pattern here.
+        result: { descr: "", type: "OK" },
+        differences: {
+          summary: {
+            proposed: "Test Event 2",
+            original: "Test Event",
+          },
+          location: {
+            proposed: "Room 2",
+            original: "Room 1",
+          },
+          dtstart: {
+            proposed:
+              /^Thursday, (September 10,|10 September) 2015 (9:00 PM|21:00) Europe\/Berlin$/,
+            original:
+              /^Wednesday, (September 0?9,|0?9 September) 2015 (9:00 PM|21:00) Europe\/Berlin$/,
+          },
+          dtend: {
+            proposed:
+              /^Thursday, (September 10,|10 September) 2015 (10:00 PM|22:00) Europe\/Berlin$/,
+            original:
+              /^Wednesday, (September 0?9,|0?9 September) 2015 (10:00 PM|22:00) Europe\/Berlin$/,
+          },
+          comment: {
+            proposed: "Sorry, I cannot make it that time.",
+            original: null,
+          },
+        },
+      },
+    },
+    {
+      name: "Test with an unsupported property has been changed",
+      input: {
+        proposed: {
+          method: "COUNTER",
+          attendee: {
+            params: { cn: "Attendee", partstat: "NEEDS-ACTION", role: "REQ-PARTICIPANT" },
+            value: "attendee@example.net",
+          },
+          location: "Room 2",
+          attach: "http://www.example2.com",
+          dtstamp: "20150909T182048Z",
+        },
+      },
+      expected: {
+        result: { descr: "", type: "OK" },
+        differences: { location: { proposed: "Room 2", original: "Room 1" } },
+      },
+    },
+    {
+      name: "Proposed change not based on the latest update of the invitation",
+      input: {
+        proposed: {
+          method: "COUNTER",
+          attendee: {
+            params: { cn: "Attendee", partstat: "NEEDS-ACTION", role: "REQ-PARTICIPANT" },
+            value: "attendee@example.net",
+          },
+          location: "Room 2",
+          dtstamp: "20150909T171048Z",
+        },
+      },
+      expected: {
+        result: {
+          descr: "This is a counterproposal not based on the latest event update.",
+          type: "NOTLATESTUPDATE",
+        },
+        differences: { location: { proposed: "Room 2", original: "Room 1" } },
+      },
+    },
+    {
+      name: "Proposed change based on a meanwhile reschuled invitation",
+      input: {
+        proposed: {
+          method: "COUNTER",
+          attendee: {
+            params: { cn: "Attendee", partstat: "NEEDS-ACTION", role: "REQ-PARTICIPANT" },
+            value: "attendee@example.net",
+          },
+          location: "Room 2",
+          sequence: "0",
+          dtstamp: "20150909T182048Z",
+        },
+      },
+      expected: {
+        result: {
+          descr: "This is a counterproposal to an already rescheduled event.",
+          type: "OUTDATED",
+        },
+        differences: { location: { proposed: "Room 2", original: "Room 1" } },
+      },
+    },
+    {
+      name: "Proposed change for an later sequence of the event",
+      input: {
+        proposed: {
+          method: "COUNTER",
+          attendee: {
+            params: { cn: "Attendee", partstat: "NEEDS-ACTION", role: "REQ-PARTICIPANT" },
+            value: "attendee@example.net",
+          },
+          location: "Room 2",
+          sequence: "2",
+          dtstamp: "20150909T182048Z",
+        },
+      },
+      expected: {
+        result: {
+          descr: "Invalid sequence number in counterproposal.",
+          type: "ERROR",
+        },
+        differences: {},
+      },
+    },
+    {
+      name: "Proposal to a different event",
+      input: {
+        proposed: {
+          method: "COUNTER",
+          uid: "cb189fdc-0000-0000-0000-31a08802249d",
+          attendee: {
+            params: { cn: "Attendee", partstat: "NEEDS-ACTION", role: "REQ-PARTICIPANT" },
+            value: "attendee@example.net",
+          },
+          location: "Room 2",
+          dtstamp: "20150909T182048Z",
+        },
+      },
+      expected: {
+        result: {
+          descr: "Mismatch of uid or organizer in counterproposal.",
+          type: "ERROR",
+        },
+        differences: {},
+      },
+    },
+    {
+      name: "Proposal with a different organizer",
+      input: {
+        proposed: {
+          method: "COUNTER",
+          organizer: {
+            params: { rsvp: "TRUE", cn: "Organizer", partstat: "ACCEPTED", role: "CHAIR" },
+            value: "organizer2@example.net",
+          },
+          attendee: {
+            params: { cn: "Attendee", partstat: "NEEDS-ACTION", role: "REQ-PARTICIPANT" },
+            value: "attendee@example.net",
+          },
+          dtstamp: "20150909T182048Z",
+        },
+      },
+      expected: {
+        result: {
+          descr: "Mismatch of uid or organizer in counterproposal.",
+          type: "ERROR",
+        },
+        differences: {},
+      },
+    },
+    {
+      name: "Counterproposal without any difference",
+      input: {
+        proposed: { method: "COUNTER" },
+      },
+      expected: {
+        result: {
+          descr: "No difference in counterproposal detected.",
+          type: "NODIFF",
+        },
+        differences: {},
+      },
+    },
+  ];
+  /* eslint-enable object-curly-newline */
+
+  let getItem = function (aProperties) {
+    let item = getIcs(aProperties);
+    return createEventFromIcalString(item);
+  };
+
+  let formatDt = function (aDateTime) {
+    if (!aDateTime) {
+      return null;
+    }
+    let datetime = cal.dtz.formatter.formatDateTime(aDateTime);
+    return datetime + " " + aDateTime.timezone.displayName;
+  };
+
+  for (let test of data) {
+    info(`testing ${test.name}`);
+    let existingItem = getItem();
+    let proposedItem = getItem(test.input.proposed);
+    let parsed = cal.invitation.parseCounter(proposedItem, existingItem);
+
+    equal(parsed.result.type, test.expected.result.type, `(test ${test.name}: result.type)`);
+    equal(parsed.result.descr, test.expected.result.descr, `(test ${test.name}: result.descr)`);
+    let parsedProps = [];
+    let additionalProps = [];
+    let missingProps = [];
+    parsed.differences.forEach(aDiff => {
+      let prop = aDiff.property.toLowerCase();
+      if (prop in test.expected.differences) {
+        let { proposed, original } = test.expected.differences[prop];
+        let foundProposed = aDiff.proposed;
+        let foundOriginal = aDiff.original;
+        if (["dtstart", "dtend"].includes(prop)) {
+          foundProposed = formatDt(foundProposed);
+          foundOriginal = formatDt(foundOriginal);
+          ok(foundProposed, `(test ${test.name}: have proposed time value for ${prop})`);
+          ok(foundOriginal, `(test ${test.name}: have original time value for ${prop})`);
+        }
+
+        if (proposed instanceof RegExp) {
+          ok(
+            proposed.test(foundProposed),
+            `(test ${test.name}: proposed "${foundProposed}" for ${prop} matches expected regex)`
+          );
+        } else {
+          equal(
+            foundProposed,
+            proposed,
+            `(test ${test.name}: proposed for ${prop} matches expected)`
+          );
+        }
+
+        if (original instanceof RegExp) {
+          ok(
+            original.test(foundOriginal),
+            `(test ${test.name}: original "${foundOriginal}" for ${prop} matches expected regex)`
+          );
+        } else {
+          equal(
+            foundOriginal,
+            original,
+            `(test ${test.name}: original for ${prop} matches expected)`
+          );
+        }
+
+        parsedProps.push(prop);
+      } else {
+        additionalProps.push(prop);
+      }
+    });
+    for (let prop in test.expected.differences) {
+      if (!parsedProps.includes(prop)) {
+        missingProps.push(prop);
+      }
+    }
+    ok(
+      additionalProps.length == 0,
+      `(test ${test.name}: should be no additional properties: ${additionalProps})`
+    );
+    ok(
+      missingProps.length == 0,
+      `(test ${test.name}: should be no missing properties: ${missingProps})`
+    );
+  }
+});
diff --git a/comm/calendar/test/unit/test_items.js b/comm/calendar/test/unit/test_items.js
new file mode 100644
index 0000000000..fb7fa38ec5
--- /dev/null
+++ b/comm/calendar/test/unit/test_items.js
@@ -0,0 +1,465 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAlarm: "resource:///modules/CalAlarm.jsm",
+  CalAttachment: "resource:///modules/CalAttachment.jsm",
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalTodo: "resource:///modules/CalTodo.jsm",
+});
+
+function run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  test_aclmanager();
+  test_calendar();
+  test_immutable();
+  test_attendee();
+  test_attachment();
+  test_lastack();
+  test_categories();
+  test_alarm();
+  test_isEvent();
+  test_isTodo();
+  test_recurring_event_properties();
+  test_recurring_todo_properties();
+  test_recurring_event_exception_properties();
+  test_recurring_todo_exception_properties();
+}
+
+function test_aclmanager() {
+  let mockCalendar = {
+    QueryInterface: ChromeUtils.generateQI(["calICalendar"]),
+
+    get superCalendar() {
+      return this;
+    },
+    get aclManager() {
+      return this;
+    },
+
+    getItemEntry(item) {
+      if (item.id == "withentry") {
+        return itemEntry;
+      }
+      return null;
+    },
+  };
+
+  let itemEntry = {
+    QueryInterface: ChromeUtils.generateQI(["calIItemACLEntry"]),
+    userCanModify: true,
+    userCanRespond: false,
+    userCanViewAll: true,
+    userCanViewDateAndTime: false,
+  };
+
+  let event = new CalEvent();
+  event.id = "withentry";
+  event.calendar = mockCalendar;
+
+  equal(event.aclEntry.userCanModify, itemEntry.userCanModify);
+  equal(event.aclEntry.userCanRespond, itemEntry.userCanRespond);
+  equal(event.aclEntry.userCanViewAll, itemEntry.userCanViewAll);
+  equal(event.aclEntry.userCanViewDateAndTime, itemEntry.userCanViewDateAndTime);
+
+  let parentEntry = new CalEvent();
+  parentEntry.id = "parententry";
+  parentEntry.calendar = mockCalendar;
+  parentEntry.parentItem = event;
+
+  equal(parentEntry.aclEntry.userCanModify, itemEntry.userCanModify);
+  equal(parentEntry.aclEntry.userCanRespond, itemEntry.userCanRespond);
+  equal(parentEntry.aclEntry.userCanViewAll, itemEntry.userCanViewAll);
+  equal(parentEntry.aclEntry.userCanViewDateAndTime, itemEntry.userCanViewDateAndTime);
+
+  event = new CalEvent();
+  event.id = "noentry";
+  event.calendar = mockCalendar;
+  equal(event.aclEntry, null);
+}
+
+function test_calendar() {
+  let event = new CalEvent();
+  let parentEntry = new CalEvent();
+
+  let mockCalendar = {
+    QueryInterface: ChromeUtils.generateQI(["calICalendar"]),
+    id: "one",
+  };
+
+  parentEntry.calendar = mockCalendar;
+  event.parentItem = parentEntry;
+
+  notEqual(event.calendar, null);
+  equal(event.calendar.id, "one");
+}
+
+function test_attachment() {
+  let e = new CalEvent();
+
+  let a = new CalAttachment();
+  a.rawData = "horst";
+
+  let b = new CalAttachment();
+  b.rawData = "bruno";
+
+  e.addAttachment(a);
+  equal(e.getAttachments().length, 1);
+
+  e.addAttachment(b);
+  equal(e.getAttachments().length, 2);
+
+  e.removeAttachment(a);
+  equal(e.getAttachments().length, 1);
+
+  e.removeAllAttachments();
+  equal(e.getAttachments().length, 0);
+}
+
+function test_attendee() {
+  let e = new CalEvent();
+  equal(e.getAttendeeById("unknown"), null);
+  equal(e.getAttendees().length, 0);
+
+  let a = new CalAttendee();
+  a.id = "mailto:horst";
+
+  let b = new CalAttendee();
+  b.id = "mailto:bruno";
+
+  e.addAttendee(a);
+  equal(e.getAttendees().length, 1);
+  equal(e.getAttendeeById("mailto:horst"), a);
+
+  e.addAttendee(b);
+  equal(e.getAttendees().length, 2);
+
+  let comp = e.icalComponent;
+  let aprop = comp.getFirstProperty("ATTENDEE");
+  equal(aprop.value, "mailto:horst");
+  aprop = comp.getNextProperty("ATTENDEE");
+  equal(aprop.value, "mailto:bruno");
+  equal(comp.getNextProperty("ATTENDEE"), null);
+
+  e.removeAttendee(a);
+  equal(e.getAttendees().length, 1);
+  equal(e.getAttendeeById("mailto:horst"), null);
+
+  e.removeAllAttendees();
+  equal(e.getAttendees().length, 0);
+}
+
+function test_categories() {
+  let e = new CalEvent();
+
+  equal(e.getCategories().length, 0);
+
+  let cat = ["a", "b", "c"];
+  e.setCategories(cat);
+
+  cat[0] = "err";
+  equal(e.getCategories().join(","), "a,b,c");
+
+  let comp = e.icalComponent;
+  let getter = comp.getFirstProperty.bind(comp);
+
+  cat[0] = "a";
+  while (cat.length) {
+    equal(cat.shift(), getter("CATEGORIES").value);
+    getter = comp.getNextProperty.bind(comp);
+  }
+}
+
+function test_alarm() {
+  let e = new CalEvent();
+  let alarm = new CalAlarm();
+
+  alarm.action = "DISPLAY";
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_ABSOLUTE;
+  alarm.alarmDate = cal.createDateTime();
+
+  e.addAlarm(alarm);
+  let ecomp = e.icalComponent;
+  let vcomp = ecomp.getFirstSubcomponent("VALARM");
+  equal(vcomp.serializeToICS(), alarm.icalString);
+
+  let alarm2 = alarm.clone();
+
+  e.addAlarm(alarm2);
+
+  equal(e.getAlarms().length, 2);
+  e.deleteAlarm(alarm);
+  equal(e.getAlarms().length, 1);
+  equal(e.getAlarms()[0], alarm2);
+
+  e.clearAlarms();
+  equal(e.getAlarms().length, 0);
+}
+
+function test_immutable() {
+  let event = new CalEvent();
+
+  let date = cal.createDateTime();
+  date.timezone = cal.timezoneService.getTimezone("Europe/Berlin");
+  event.alarmLastAck = date;
+
+  let org = new CalAttendee();
+  org.id = "one";
+  event.organizer = org;
+
+  let alarm = new CalAlarm();
+  alarm.action = "DISPLAY";
+  alarm.description = "foo";
+  alarm.related = Ci.calIAlarm.ALARM_RELATED_START;
+  alarm.offset = cal.createDuration("PT1S");
+  event.addAlarm(alarm);
+
+  event.setProperty("X-NAME", "X-VALUE");
+  event.setPropertyParameter("X-NAME", "X-PARAM", "X-PARAMVAL");
+
+  event.setCategories(["a", "b", "c"]);
+
+  equal(event.alarmLastAck.timezone.tzid, cal.dtz.UTC.tzid);
+
+  event.makeImmutable();
+
+  // call again, should not throw
+  event.makeImmutable();
+
+  ok(!event.alarmLastAck.isMutable);
+  ok(!org.isMutable);
+  ok(!alarm.isMutable);
+
+  throws(() => {
+    event.alarmLastAck = cal.createDateTime();
+  }, /Can not modify immutable data container/);
+  throws(() => {
+    event.calendar = null;
+  }, /Can not modify immutable data container/);
+  throws(() => {
+    event.parentItem = null;
+  }, /Can not modify immutable data container/);
+  throws(() => {
+    event.setCategories(["d", "e", "f"]);
+  }, /Can not modify immutable data container/);
+
+  let event2 = event.clone();
+  event2.organizer.id = "two";
+
+  equal(org.id, "one");
+  equal(event2.organizer.id, "two");
+
+  equal(event2.getProperty("X-NAME"), "X-VALUE");
+  equal(event2.getPropertyParameter("X-NAME", "X-PARAM"), "X-PARAMVAL");
+
+  event2.setPropertyParameter("X-NAME", "X-PARAM", null);
+  equal(event2.getPropertyParameter("X-NAME", "X-PARAM"), null);
+
+  // TODO more clone checks
+}
+
+function test_lastack() {
+  let e = new CalEvent();
+
+  e.alarmLastAck = cal.createDateTime("20120101T010101");
+
+  // Our items don't support this yet
+  //  equal(e.getProperty("X-MOZ-LASTACK"), "20120101T010101");
+
+  let comp = e.icalComponent;
+  let prop = comp.getFirstProperty("X-MOZ-LASTACK");
+
+  equal(prop.value, "20120101T010101Z");
+
+  prop.value = "20120101T010102Z";
+
+  e.icalComponent = comp;
+
+  equal(e.alarmLastAck.icalString, "20120101T010102Z");
+}
+
+/**
+ * Test isEvent() returns the correct value for events and todos.
+ */
+function test_isEvent() {
+  let event = new CalEvent();
+  let todo = new CalTodo();
+
+  Assert.ok(event.isEvent(), "isEvent() returns true for events");
+  Assert.ok(!todo.isEvent(), "isEvent() returns false for todos");
+}
+
+/**
+ * Test isTodo() returns the correct value for events and todos.
+ */
+function test_isTodo() {
+  let todo = new CalTodo();
+  let event = new CalEvent();
+
+  Assert.ok(todo.isTodo(), "isTodo() returns true for todos");
+  Assert.ok(!event.isTodo(), "isTodo() returns false for events");
+}
+
+/**
+ * Function for testing that the "properties" property of each supplied
+ * calItemBase occurrence includes those inherited from the parent.
+ *
+ * @param {calItemBase[]} items - A list of item occurrences to test.
+ * @param {calItemBase} parent - The item to use as the parent.
+ * @param {object} [overrides] - A set of key value pairs than can be passed
+ *                                 to indicate what to expect for some properties.
+ */
+function doPropertiesTest(items, parent, overrides = {}) {
+  let skippedProps = ["DTSTART", "DTEND"];
+  let toString = value =>
+    value && value instanceof Ci.calIDateTime ? value.icalString : value && value.toString();
+
+  for (let item of items) {
+    info(`Testing occurrence with recurrenceId="${item.recurrenceId.icalString}...`);
+
+    let parentProperties = new Map(parent.properties);
+    let itemProperties = new Map(item.properties);
+    for (let [name, value] of parentProperties.entries()) {
+      if (!skippedProps.includes(name)) {
+        if (overrides[name]) {
+          Assert.equal(
+            toString(itemProperties.get(name)),
+            toString(overrides[name]),
+            `"${name}" value is value expected by overrides`
+          );
+        } else {
+          Assert.equal(
+            toString(itemProperties.get(name)),
+            toString(value),
+            `"${name}" value is same as parent`
+          );
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Test the "properties" property of a recurring CalEvent inherits parent
+ * properties properly.
+ */
+function test_recurring_event_properties() {
+  let event = new CalEvent(CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      DTSTAMP:20210716T000000Z
+      UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5
+      SUMMARY:Parent Event
+      CATEGORIES:Business
+      LOCATION: Mochitest
+      DTSTART:20210716T000000Z
+      DTEND:20210716T110000Z
+      RRULE:FREQ=DAILY;UNTIL=20210719T110000Z
+      DESCRIPTION:This is the main event.
+      END:VEVENT
+    `);
+  let occurrences = event.recurrenceInfo.getOccurrences(
+    cal.createDateTime("20210701"),
+    cal.createDateTime("20210731"),
+    Infinity
+  );
+  doPropertiesTest(occurrences, event.parentItem);
+}
+
+/**
+ * Test the "properties" property of a recurring CalEvent exception inherits
+ * parent properties properly.
+ */
+function test_recurring_event_exception_properties() {
+  let event = new CalEvent(CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      DTSTAMP:20210716T000000Z
+      UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5
+      SUMMARY:Parent Event
+      CATEGORIES:Business
+      LOCATION: Mochitest
+      DTSTART:20210716T000000Z
+      DTEND:20210716T110000Z
+      RRULE:FREQ=DAILY;UNTIL=20210719T110000Z
+      DESCRIPTION:This is the main event.
+      END:VEVENT
+    `);
+  let occurrences = event.recurrenceInfo.getOccurrences(
+    cal.createDateTime("20210701"),
+    cal.createDateTime("20210731"),
+    Infinity
+  );
+  let target = occurrences[0].clone();
+  let newDescription = "This is an exception.";
+  target.setProperty("DESCRIPTION", newDescription);
+  event.parentItem.recurrenceInfo.modifyException(target);
+  target = event.parentItem.recurrenceInfo.getExceptionFor(target.recurrenceId);
+  Assert.ok(target);
+  doPropertiesTest([target], event.parentItem, { DESCRIPTION: newDescription });
+}
+
+/**
+ * Test the "properties" property of a recurring CalTodo inherits parent
+ * properties properly.
+ */
+function test_recurring_todo_properties() {
+  let task = new CalTodo(CalendarTestUtils.dedent`
+      BEGIN:VTODO
+      DTSTAMP:20210716T225440Z
+      UID:673e125d-fe6b-465d-8a38-9c9373ca9705
+      SUMMARY:Main Task
+      RRULE:FREQ=DAILY;UNTIL=20210719T230000Z
+      DTSTART;TZID=America/Port_of_Spain:20210716T190000
+      PERCENT-COMPLETE:0
+      LOCATION:Mochitest
+      DESCRIPTION:This is the main task.
+      END:VTODO
+    `);
+  let occurrences = task.recurrenceInfo.getOccurrences(
+    cal.createDateTime("20210701"),
+    cal.createDateTime("20210731"),
+    Infinity
+  );
+  doPropertiesTest(occurrences, task.parentItem);
+}
+
+/**
+ * Test the "properties" property of a recurring CalTodo exception inherits
+ * parent properties properly.
+ */
+function test_recurring_todo_exception_properties() {
+  let task = new CalTodo(CalendarTestUtils.dedent`
+      BEGIN:VTODO
+      DTSTAMP:20210716T225440Z
+      UID:673e125d-fe6b-465d-8a38-9c9373ca9705
+      SUMMARY:Main Task
+      RRULE:FREQ=DAILY;UNTIL=20210719T230000Z
+      DTSTART;TZID=America/Port_of_Spain:20210716T190000
+      PERCENT-COMPLETE:0
+      LOCATION:Mochitest
+      DESCRIPTION:This is the main task.
+      END:VTODO
+    `);
+  let occurrences = task.recurrenceInfo.getOccurrences(
+    cal.createDateTime("20210701"),
+    cal.createDateTime("20210731"),
+    Infinity
+  );
+  let target = occurrences[0].clone();
+  let newDescription = "This is an exception.";
+  target.setProperty("DESCRIPTION", newDescription);
+  task.parentItem.recurrenceInfo.modifyException(target);
+  target = task.parentItem.recurrenceInfo.getExceptionFor(target.recurrenceId);
+  Assert.ok(target);
+  doPropertiesTest([target], task.parentItem, { DESCRIPTION: newDescription });
+}
diff --git a/comm/calendar/test/unit/test_itip_message_sender.js b/comm/calendar/test/unit/test_itip_message_sender.js
new file mode 100644
index 0000000000..77a110a875
--- /dev/null
+++ b/comm/calendar/test/unit/test_itip_message_sender.js
@@ -0,0 +1,358 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+const { CalAttendee } = ChromeUtils.import("resource:///modules/CalAttendee.jsm");
+var { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+var { CalItipMessageSender } = ChromeUtils.import("resource:///modules/CalItipMessageSender.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+const identityEmail = "user@example.com";
+const eventOrganizerEmail = "eventorganizer@example.com";
+
+/**
+ * Creates a calendar event mimicking an event to which we have received an
+ * invitation.
+ *
+ * @param {string} organizerEmail - The email address of the event organizer.
+ * @param {string} attendeeEmail - The email address of an attendee who has
+ *   accepted the invitation.
+ * @returns {calIItemBase} - The new calendar event.
+ */
+function createIncomingEvent(organizerEmail, attendeeEmail) {
+  const organizerId = cal.email.prependMailTo(organizerEmail);
+  const attendeeId = cal.email.prependMailTo(attendeeEmail);
+
+  const icalString = CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      CREATED:20210105T000000Z
+      DTSTAMP:20210501T000000Z
+      UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5
+      SUMMARY:Test Invitation
+      DTSTART:20210105T000000Z
+      DTEND:20210105T100000Z
+      STATUS:CONFIRMED
+      SUMMARY:Test Event
+      ORGANIZER;CN=${organizerEmail}:${organizerId}
+      ATTENDEE;CUTYPE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;PARTSTAT=ACCEPTED;
+        RSVP=TRUE;CN=other@example.com;:mailto:other@example.com
+      ATTENDEE;CUTYPE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;PARTSTAT=ACCEPTED;
+        RSVP=TRUE;CN=${attendeeEmail};:${attendeeId}
+      X-MOZ-RECEIVED-SEQUENCE:0
+      X-MOZ-RECEIVED-DTSTAMP:20210501T000000Z
+      X-MOZ-GENERATION:0
+      END:VEVENT
+    `;
+
+  return new CalEvent(icalString);
+}
+
+let calendar;
+
+/**
+ * Ensure the calendar manager is available, initialize the calendar and
+ * identity we use for testing.
+ */
+add_setup(async function () {
+  do_get_profile();
+
+  await new Promise(resolve => do_load_calmgr(resolve));
+  calendar = CalendarTestUtils.createCalendar("Test", "memory");
+
+  const identity = MailServices.accounts.createIdentity();
+  identity.email = identityEmail;
+
+  const account = MailServices.accounts.createAccount();
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    `${account.key}user`,
+    "localhost",
+    "none"
+  );
+  account.addIdentity(identity);
+
+  registerCleanupFunction(() => {
+    MailServices.accounts.removeIncomingServer(account.incomingServer, false);
+    MailServices.accounts.removeAccount(account);
+  });
+
+  calendar.setProperty("imip.identity.key", identity.key);
+  calendar.setProperty("organizerId", cal.email.prependMailTo(identityEmail));
+});
+
+add_task(async function testAddAttendeesToOwnEvent() {
+  const icalString = CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      CREATED:20210105T000000Z
+      DTSTAMP:20210501T000000Z
+      UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5
+      SUMMARY:Test Invitation
+      DTSTART:20210105T000000Z
+      DTEND:20210105T100000Z
+      STATUS:CONFIRMED
+      SUMMARY:Test Event
+      X-MOZ-SEND-INVITATIONS:TRUE
+      END:VEVENT
+    `;
+
+  const item = new CalEvent(icalString);
+  const savedItem = await calendar.addItem(item);
+
+  // Modify the event to include an attendee not in the original, as well as the
+  // organizer. As of the writing of this test, this is the expected behavior
+  // for adding an attendee to an event which previously had none.
+  const newAttendeeEmail = "foo@example.com";
+  const newAttendee = new CalAttendee();
+  newAttendee.id = newAttendeeEmail;
+
+  const organizer = new CalAttendee();
+  organizer.isOrganizer = true;
+  organizer.id = identityEmail;
+
+  const organizerAsAttendee = new CalAttendee();
+  organizerAsAttendee.id = identityEmail;
+
+  const targetItem = savedItem.clone();
+  targetItem.addAttendee(newAttendee);
+  targetItem.addAttendee(organizer);
+  targetItem.addAttendee(organizerAsAttendee);
+  const modifiedItem = await calendar.modifyItem(targetItem, savedItem);
+
+  // Test that a sender with an original item and for which the current user is
+  // both an attendee and the organizer will generate a REQUEST, but not send a
+  // message to the organizer.
+  const sender = new CalItipMessageSender(savedItem, null);
+
+  const result = sender.buildOutgoingMessages(Ci.calIOperationListener.MODIFY, modifiedItem);
+  Assert.equal(result, 1, "return value should indicate there are pending messages");
+  Assert.equal(sender.pendingMessageCount, 1, "there should be one pending message");
+
+  const [msg] = sender.pendingMessages;
+  Assert.equal(msg.method, "REQUEST", "message method should be 'REQUEST'");
+  Assert.equal(msg.recipients.length, 1, "message should have one recipient");
+
+  const [recipient] = msg.recipients;
+  Assert.equal(
+    recipient.id,
+    cal.email.prependMailTo(newAttendeeEmail),
+    "recipient should be the non-organizer attendee"
+  );
+
+  await calendar.deleteItem(modifiedItem);
+
+  // Now also cancel the event. No mail should be sent to self.
+  const targetItem2 = modifiedItem.clone();
+
+  targetItem2.setProperty("STATUS", "CANCELLED");
+  targetItem2.setProperty("SEQUENCE", "2");
+  const modifiedItem2 = await calendar.addItem(targetItem2);
+  const sender2 = new CalItipMessageSender(modifiedItem2, null);
+
+  const result2 = sender2.buildOutgoingMessages(Ci.calIOperationListener.MODIFY, modifiedItem2);
+  Assert.equal(result2, 1, "return value should indicate there are pending messages");
+  Assert.equal(sender2.pendingMessageCount, 1, "there should be one pending message");
+
+  const [msg2] = sender2.pendingMessages;
+  Assert.equal(msg2.method, "CANCEL", "deletion message method should be 'CANCEL'");
+  Assert.equal(msg2.recipients.length, 1, "deletion message should have one recipient");
+
+  const [recipient2] = msg2.recipients;
+  Assert.equal(
+    recipient2.id,
+    cal.email.prependMailTo(newAttendeeEmail),
+    "for deletion message, recipient should be the non-organizer attendee"
+  );
+});
+
+add_task(async function testAddAdditionalAttendee() {
+  const icalString = CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      CREATED:20210105T000000Z
+      DTSTAMP:20210501T000000Z
+      UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5
+      SUMMARY:Test Invitation
+      DTSTART:20210105T000000Z
+      DTEND:20210105T100000Z
+      STATUS:CONFIRMED
+      SUMMARY:Test Event
+      ORGANIZER;CN=${identityEmail}:${cal.email.prependMailTo(identityEmail)}
+      ATTENDEE;CUTYPE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;PARTSTAT=ACCEPTED;
+        RSVP=TRUE;CN=other@example.com;:mailto:other@example.com
+      ATTENDEE;CUTYPE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;PARTSTAT=ACCEPTED;
+        RSVP=TRUE;CN=${identityEmail};:${cal.email.prependMailTo(identityEmail)}
+      X-MOZ-SEND-INVITATIONS:TRUE
+      END:VEVENT
+    `;
+
+  const item = new CalEvent(icalString);
+  const savedItem = await calendar.addItem(item);
+
+  // Modify the event to include an attendee not in the original.
+  const newAttendeeEmail = "bar@example.com";
+  const newAttendee = new CalAttendee();
+  newAttendee.id = newAttendeeEmail;
+
+  const organizer = new CalAttendee();
+  organizer.isOrganizer = true;
+  organizer.id = identityEmail;
+
+  const organizerAsAttendee = new CalAttendee();
+  organizerAsAttendee.id = identityEmail;
+
+  const targetItem = savedItem.clone();
+  targetItem.addAttendee(newAttendee);
+  const modifiedItem = await calendar.modifyItem(targetItem, savedItem);
+
+  // Test that adding an attendee won't cause messages to be sent to the
+  // existing attendees.
+  const sender = new CalItipMessageSender(savedItem, null);
+
+  const result = sender.buildOutgoingMessages(Ci.calIOperationListener.MODIFY, modifiedItem);
+  Assert.equal(result, 1, "return value should indicate there are pending messages");
+  Assert.equal(sender.pendingMessageCount, 1, "there should be one pending message");
+
+  const [msg] = sender.pendingMessages;
+  Assert.equal(msg.method, "REQUEST", "message method should be 'REQUEST'");
+  Assert.equal(msg.recipients.length, 1, "message should have one recipient");
+
+  const [recipient] = msg.recipients;
+  Assert.equal(
+    recipient.id,
+    cal.email.prependMailTo(newAttendeeEmail),
+    "recipient should be the new attendee"
+  );
+
+  await calendar.deleteItem(modifiedItem);
+});
+
+add_task(async function testInvitationReceived() {
+  const item = createIncomingEvent(eventOrganizerEmail, identityEmail);
+  const savedItem = await calendar.addItem(item);
+
+  const attendeeId = cal.email.prependMailTo(identityEmail);
+
+  // Test that a sender with no original item and for which the current user is
+  // an attendee but not the organizer (representing a new incoming invitation)
+  // generates a single pending REPLY message on ADD.
+  const currentUserAsAttendee = savedItem.getAttendeeById(attendeeId);
+  const sender = new CalItipMessageSender(null, currentUserAsAttendee);
+
+  const result = sender.buildOutgoingMessages(Ci.calIOperationListener.ADD, savedItem);
+  Assert.equal(result, 1, "return value should indicate there are pending messages");
+  Assert.equal(sender.pendingMessageCount, 1, "there should be one pending message");
+
+  const [msg] = sender.pendingMessages;
+  Assert.equal(msg.method, "REPLY", "message method should be 'REPLY'");
+  Assert.equal(msg.recipients.length, 1, "message should have one recipient");
+
+  const [recipient] = msg.recipients;
+  Assert.equal(
+    recipient.id,
+    cal.email.prependMailTo(eventOrganizerEmail),
+    "recipient should be the event organizer"
+  );
+
+  const attendeeList = msg.item.getAttendees();
+  Assert.equal(attendeeList.length, 1, "there should be one attendee listed in the message");
+
+  const [attendee] = attendeeList;
+  Assert.equal(attendee.id, attendeeId, "listed attendee should be the current user");
+  Assert.equal(
+    attendee.participationStatus,
+    "ACCEPTED",
+    "current user's participation status should be 'ACCEPTED'"
+  );
+
+  await calendar.deleteItem(savedItem);
+});
+
+add_task(async function testParticipationStatusUpdated() {
+  const item = createIncomingEvent(eventOrganizerEmail, identityEmail);
+  const savedItem = await calendar.addItem(item);
+
+  const attendeeId = cal.email.prependMailTo(identityEmail);
+
+  // Modify the event to update the user's participation status.
+  const targetItem = savedItem.clone();
+  const currentUserAsAttendee = targetItem.getAttendeeById(attendeeId);
+  currentUserAsAttendee.participationStatus = "TENTATIVE";
+  const modifiedItem = await calendar.modifyItem(targetItem, savedItem);
+
+  // Test that a sender for which the current user is an attendee but not the
+  // organizer will generate a pending REPLY message on MODIFY.
+  const sender = new CalItipMessageSender(savedItem, currentUserAsAttendee);
+  const result = sender.buildOutgoingMessages(Ci.calIOperationListener.MODIFY, modifiedItem);
+
+  Assert.equal(result, 1, "return value should indicate there are pending messages");
+  Assert.equal(sender.pendingMessageCount, 1, "there should be one pending message");
+
+  const [msg] = sender.pendingMessages;
+  Assert.equal(msg.method, "REPLY", "message method should be 'REPLY'");
+  Assert.equal(msg.recipients.length, 1, "message should have one recipient");
+
+  const [recipient] = msg.recipients;
+  Assert.equal(
+    recipient.id,
+    cal.email.prependMailTo(eventOrganizerEmail),
+    "recipient should be the event organizer"
+  );
+
+  const attendeeList = msg.item.getAttendees();
+  Assert.equal(attendeeList.length, 1, "there should be one attendee listed in the message");
+
+  const [attendee] = attendeeList;
+  Assert.equal(attendee.id, attendeeId, "listed attendee should be the current user");
+  Assert.equal(
+    attendee.participationStatus,
+    "TENTATIVE",
+    "current user's participation status should be 'TENTATIVE'"
+  );
+
+  await calendar.deleteItem(modifiedItem);
+});
+
+add_task(async function testEventDeleted() {
+  const item = createIncomingEvent(eventOrganizerEmail, identityEmail);
+  const savedItem = await calendar.addItem(item);
+
+  const attendeeId = cal.email.prependMailTo(identityEmail);
+
+  await calendar.deleteItem(savedItem);
+  const currentUserAsAttendee = savedItem.getAttendeeById(attendeeId);
+
+  // Test that a sender with no original item and for which the current user is
+  // an attendee but not the organizer (representing the user deleting an event
+  // from their calendar) generates a single REPLY message to the organizer on
+  // DELETE.
+  const sender = new CalItipMessageSender(null, currentUserAsAttendee);
+  const result = sender.buildOutgoingMessages(Ci.calIOperationListener.DELETE, savedItem);
+
+  Assert.equal(result, 1, "return value should indicate there are pending messages");
+  Assert.equal(sender.pendingMessageCount, 1, "there should be one pending message");
+
+  const [msg] = sender.pendingMessages;
+  Assert.equal(msg.method, "REPLY", "message method should be 'REPLY'");
+  Assert.equal(msg.recipients.length, 1, "message should have one recipient");
+
+  const [recipient] = msg.recipients;
+  Assert.equal(
+    recipient.id,
+    cal.email.prependMailTo(eventOrganizerEmail),
+    "recipient should be the event organizer"
+  );
+
+  const attendeeList = msg.item.getAttendees();
+  Assert.equal(attendeeList.length, 1, "there should be one attendee listed in the message");
+
+  const [attendee] = attendeeList;
+  Assert.equal(attendee.id, attendeeId, "listed attendee should be the current user");
+  Assert.equal(
+    attendee.participationStatus,
+    "DECLINED",
+    "current user's participation status should be 'DECLINED'"
+  );
+});
diff --git a/comm/calendar/test/unit/test_itip_utils.js b/comm/calendar/test/unit/test_itip_utils.js
new file mode 100644
index 0000000000..5c4678ab1d
--- /dev/null
+++ b/comm/calendar/test/unit/test_itip_utils.js
@@ -0,0 +1,831 @@
+/* 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 { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+var { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+var { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalItipEmailTransport: "resource:///modules/CalItipEmailTransport.jsm",
+});
+
+// tests for calItipUtils.jsm
+
+do_get_profile();
+
+/*
+ * Helper function to get an ics for testing sequence and stamp comparison
+ *
+ * @param {String} aAttendee - A serialized ATTENDEE property
+ * @param {String} aSequence - A serialized SEQUENCE property
+ * @param {String} aDtStamp - A serialized DTSTAMP property
+ * @param {String} aXMozReceivedSequence - A serialized X-MOZ-RECEIVED-SEQUENCE property
+ * @param {String} aXMozReceivedDtStamp - A serialized X-MOZ-RECEIVED-STAMP property
+ */
+function getSeqStampTestIcs(aProperties) {
+  // we make sure to have a dtstamp property to get a valid ics
+  let dtStamp = "20150909T181048Z";
+  let additionalProperties = "";
+  aProperties.forEach(aProp => {
+    if (aProp.startsWith("DTSTAMP:")) {
+      dtStamp = aProp;
+    } else {
+      additionalProperties += "\r\n" + aProp;
+    }
+  });
+
+  return [
+    "BEGIN:VCALENDAR",
+    "PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN",
+    "VERSION:2.0",
+    "METHOD:REQUEST",
+    "BEGIN:VTIMEZONE",
+    "TZID:Europe/Berlin",
+    "BEGIN:DAYLIGHT",
+    "TZOFFSETFROM:+0100",
+    "TZOFFSETTO:+0200",
+    "TZNAME:CEST",
+    "DTSTART:19700329T020000",
+    "RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU",
+    "END:DAYLIGHT",
+    "BEGIN:STANDARD",
+    "TZOFFSETFROM:+0200",
+    "TZOFFSETTO:+0100",
+    "TZNAME:CET",
+    "DTSTART:19701025T030000",
+    "RRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU",
+    "END:STANDARD",
+    "END:VTIMEZONE",
+    "BEGIN:VEVENT",
+    "CREATED:20150909T180909Z",
+    "LAST-MODIFIED:20150909T181048Z",
+    dtStamp,
+    "UID:cb189fdc-ed47-4db6-a8d7-31a08802249d",
+    "SUMMARY:Test Event",
+    "ORGANIZER;RSVP=TRUE;CN=Organizer;PARTSTAT=ACCEPTED;ROLE=CHAIR:mailto:organizer@example.net",
+    "ATTENDEE;RSVP=TRUE;CN=Attendee;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT:mailto:attende" +
+      "e@example.net" +
+      additionalProperties,
+    "DTSTART;TZID=Europe/Berlin:20150909T210000",
+    "DTEND;TZID=Europe/Berlin:20150909T220000",
+    "TRANSP:OPAQUE",
+    "LOCATION:Room 1",
+    "DESCRIPTION:Let us get together",
+    "URL:http://www.example.com",
+    "ATTACH:http://www.example.com",
+    "END:VEVENT",
+    "END:VCALENDAR",
+  ].join("\r\n");
+}
+
+function getSeqStampTestItems(aTest) {
+  let items = [];
+  for (let input of aTest.input) {
+    if (input.item) {
+      // in this case, we need to return an event
+      let attendee = "";
+      if ("attendee" in input.item && input.item.attendee != {}) {
+        let att = new CalAttendee();
+        att.id = input.item.attendee.id || "mailto:otherattendee@example.net";
+        if ("receivedSeq" in input.item.attendee && input.item.attendee.receivedSeq.length) {
+          att.setProperty("RECEIVED-SEQUENCE", input.item.attendee.receivedSeq);
+        }
+        if ("receivedStamp" in input.item.attendee && input.item.attendee.receivedStamp.length) {
+          att.setProperty("RECEIVED-DTSTAMP", input.item.attendee.receivedStamp);
+        }
+      }
+      let sequence = "";
+      if ("sequence" in input.item && input.item.sequence.length) {
+        sequence = "SEQUENCE:" + input.item.sequence;
+      }
+      let dtStamp = "DTSTAMP:20150909T181048Z";
+      if ("dtStamp" in input.item && input.item.dtStamp) {
+        dtStamp = "DTSTAMP:" + input.item.dtStamp;
+      }
+      let xMozReceivedSeq = "";
+      if ("xMozReceivedSeq" in input.item && input.item.xMozReceivedSeq.length) {
+        xMozReceivedSeq = "X-MOZ-RECEIVED-SEQUENCE:" + input.item.xMozReceivedSeq;
+      }
+      let xMozReceivedStamp = "";
+      if ("xMozReceivedStamp" in input.item && input.item.xMozReceivedStamp.length) {
+        xMozReceivedStamp = "X-MOZ-RECEIVED-DTSTAMP:" + input.item.xMozReceivedStamp;
+      }
+      let xMsAptSeq = "";
+      if ("xMsAptSeq" in input.item && input.item.xMsAptSeq.length) {
+        xMsAptSeq = "X-MICROSOFT-CDO-APPT-SEQUENCE:" + input.item.xMsAptSeq;
+      }
+      let testItem = new CalEvent();
+      testItem.icalString = getSeqStampTestIcs([
+        attendee,
+        sequence,
+        dtStamp,
+        xMozReceivedSeq,
+        xMozReceivedStamp,
+        xMsAptSeq,
+      ]);
+      items.push(testItem);
+    } else {
+      // in this case, we need to return an attendee
+      let att = new CalAttendee();
+      att.id = input.attendee.id || "mailto:otherattendee@example.net";
+      if (input.attendee.receivedSeq && input.attendee.receivedSeq.length) {
+        att.setProperty("RECEIVED-SEQUENCE", input.attendee.receivedSeq);
+      }
+      if (input.attendee.receivedStamp && input.attendee.receivedStamp.length) {
+        att.setProperty("RECEIVED-DTSTAMP", input.attendee.receivedStamp);
+      }
+      items.push(att);
+    }
+  }
+  return items;
+}
+
+add_task(function test_getMessageSender() {
+  let data = [
+    {
+      input: null,
+      expected: null,
+    },
+    {
+      input: {},
+      expected: null,
+    },
+    {
+      input: { author: "Sender 1 <sender1@example.net>" },
+      expected: "sender1@example.net",
+    },
+  ];
+  for (let i = 1; i <= data.length; i++) {
+    let test = data[i - 1];
+    equal(cal.itip.getMessageSender(test.input), test.expected, "(test #" + i + ")");
+  }
+});
+
+add_task(function test_getSequence() {
+  // assigning an empty string results in not having the property in the ics here
+  let data = [
+    {
+      input: [{ item: { sequence: "", xMozReceivedSeq: "" } }],
+      expected: 0,
+    },
+    {
+      input: [{ item: { sequence: "0", xMozReceivedSeq: "" } }],
+      expected: 0,
+    },
+    {
+      input: [{ item: { sequence: "", xMozReceivedSeq: "0" } }],
+      expected: 0,
+    },
+    {
+      input: [{ item: { sequence: "1", xMozReceivedSeq: "" } }],
+      expected: 1,
+    },
+    {
+      input: [{ item: { sequence: "", xMozReceivedSeq: "1" } }],
+      expected: 1,
+    },
+    {
+      input: [{ attendee: { receivedSeq: "" } }],
+      expected: 0,
+    },
+    {
+      input: [{ attendee: { receivedSeq: "0" } }],
+      expected: 0,
+    },
+    {
+      input: [{ attendee: { receivedSeq: "1" } }],
+      expected: 1,
+    },
+  ];
+  for (let i = 1; i <= data.length; i++) {
+    let test = data[i - 1];
+    let testItems = getSeqStampTestItems(test);
+    equal(cal.itip.getSequence(testItems[0], testItems[1]), test.expected, "(test #" + i + ")");
+  }
+});
+
+add_task(function test_getStamp() {
+  // assigning an empty string results in not having the property in the ics here. However, there
+  // must be always an dtStamp for item - if it's missing it will be set by the test code to make
+  // sure we get a valid ics
+  let data = [
+    {
+      // !dtStamp && !xMozReceivedStamp => test default value
+      input: [{ item: { dtStamp: "", xMozReceivedStamp: "" } }],
+      expected: "20150909T181048Z",
+    },
+    {
+      // dtStamp && !xMozReceivedStamp => dtStamp
+      input: [{ item: { dtStamp: "20150910T181048Z", xMozReceivedStamp: "" } }],
+      expected: "20150910T181048Z",
+    },
+    {
+      // dtStamp && xMozReceivedStamp => xMozReceivedStamp
+      input: [{ item: { dtStamp: "20150909T181048Z", xMozReceivedStamp: "20150910T181048Z" } }],
+      expected: "20150910T181048Z",
+    },
+    {
+      input: [{ attendee: { receivedStamp: "" } }],
+      expected: null,
+    },
+    {
+      input: [{ attendee: { receivedStamp: "20150910T181048Z" } }],
+      expected: "20150910T181048Z",
+    },
+  ];
+  for (let i = 1; i <= data.length; i++) {
+    let test = data[i - 1];
+    let result = cal.itip.getStamp(getSeqStampTestItems(test)[0]);
+    if (result) {
+      result = result.icalString;
+    }
+    equal(result, test.expected, "(test #" + i + ")");
+  }
+});
+
+add_task(function test_compareSequence() {
+  // it is sufficient to test here with sequence for items - full test coverage for
+  // x-moz-received-sequence is already provided by test_compareSequence
+  let data = [
+    {
+      // item1.seq == item2.seq
+      input: [{ item: { sequence: "2" } }, { item: { sequence: "2" } }],
+      expected: 0,
+    },
+    {
+      // item1.seq > item2.seq
+      input: [{ item: { sequence: "3" } }, { item: { sequence: "2" } }],
+      expected: 1,
+    },
+    {
+      // item1.seq < item2.seq
+      input: [{ item: { sequence: "2" } }, { item: { sequence: "3" } }],
+      expected: -1,
+    },
+    {
+      // attendee1.seq == attendee2.seq
+      input: [{ attendee: { receivedSeq: "2" } }, { attendee: { receivedSeq: "2" } }],
+      expected: 0,
+    },
+    {
+      // attendee1.seq > attendee2.seq
+      input: [{ attendee: { receivedSeq: "3" } }, { attendee: { receivedSeq: "2" } }],
+      expected: 1,
+    },
+    {
+      // attendee1.seq < attendee2.seq
+      input: [{ attendee: { receivedSeq: "2" } }, { attendee: { receivedSeq: "3" } }],
+      expected: -1,
+    },
+    {
+      // item.seq == attendee.seq
+      input: [{ item: { sequence: "2" } }, { attendee: { receivedSeq: "2" } }],
+      expected: 0,
+    },
+    {
+      // item.seq > attendee.seq
+      input: [{ item: { sequence: "3" } }, { attendee: { receivedSeq: "2" } }],
+      expected: 1,
+    },
+    {
+      // item.seq < attendee.seq
+      input: [{ item: { sequence: "2" } }, { attendee: { receivedSeq: "3" } }],
+      expected: -1,
+    },
+  ];
+  for (let i = 1; i <= data.length; i++) {
+    let test = data[i - 1];
+    let testItems = getSeqStampTestItems(test);
+    equal(cal.itip.compareSequence(testItems[0], testItems[1]), test.expected, "(test #" + i + ")");
+  }
+});
+
+add_task(function test_compareStamp() {
+  // it is sufficient to test here with dtstamp for items - full test coverage for
+  // x-moz-received-stamp is already provided by test_compareStamp
+  let data = [
+    {
+      // item1.stamp == item2.stamp
+      input: [{ item: { dtStamp: "20150910T181048Z" } }, { item: { dtStamp: "20150910T181048Z" } }],
+      expected: 0,
+    },
+    {
+      // item1.stamp > item2.stamp
+      input: [{ item: { dtStamp: "20150911T181048Z" } }, { item: { dtStamp: "20150910T181048Z" } }],
+      expected: 1,
+    },
+    {
+      // item1.stamp < item2.stamp
+      input: [{ item: { dtStamp: "20150910T181048Z" } }, { item: { dtStamp: "20150911T181048Z" } }],
+      expected: -1,
+    },
+    {
+      // attendee1.stamp == attendee2.stamp
+      input: [
+        { attendee: { receivedStamp: "20150910T181048Z" } },
+        { attendee: { receivedStamp: "20150910T181048Z" } },
+      ],
+      expected: 0,
+    },
+    {
+      // attendee1.stamp > attendee2.stamp
+      input: [
+        { attendee: { receivedStamp: "20150911T181048Z" } },
+        { attendee: { receivedStamp: "20150910T181048Z" } },
+      ],
+      expected: 1,
+    },
+    {
+      // attendee1.stamp < attendee2.stamp
+      input: [
+        { attendee: { receivedStamp: "20150910T181048Z" } },
+        { attendee: { receivedStamp: "20150911T181048Z" } },
+      ],
+      expected: -1,
+    },
+    {
+      // item.stamp == attendee.stamp
+      input: [
+        { item: { dtStamp: "20150910T181048Z" } },
+        { attendee: { receivedStamp: "20150910T181048Z" } },
+      ],
+      expected: 0,
+    },
+    {
+      // item.stamp > attendee.stamp
+      input: [
+        { item: { dtStamp: "20150911T181048Z" } },
+        { attendee: { receivedStamp: "20150910T181048Z" } },
+      ],
+      expected: 1,
+    },
+    {
+      // item.stamp < attendee.stamp
+      input: [
+        { item: { dtStamp: "20150910T181048Z" } },
+        { attendee: { receivedStamp: "20150911T181048Z" } },
+      ],
+      expected: -1,
+    },
+  ];
+  for (let i = 1; i <= data.length; i++) {
+    let test = data[i - 1];
+    let testItems = getSeqStampTestItems(test);
+    equal(cal.itip.compareStamp(testItems[0], testItems[1]), test.expected, "(test #" + i + ")");
+  }
+});
+
+add_task(function test_compare() {
+  // it is sufficient to test here with items only - full test coverage for attendees or
+  // item/attendee is already provided by test_compareSequence and test_compareStamp
+  let data = [
+    {
+      // item1.seq == item2.seq && item1.stamp == item2.stamp
+      input: [
+        { item: { sequence: "2", dtStamp: "20150910T181048Z" } },
+        { item: { sequence: "2", dtStamp: "20150910T181048Z" } },
+      ],
+      expected: 0,
+    },
+    {
+      // item1.seq == item2.seq && item1.stamp > item2.stamp
+      input: [
+        { item: { sequence: "2", dtStamp: "20150911T181048Z" } },
+        { item: { sequence: "2", dtStamp: "20150910T181048Z" } },
+      ],
+      expected: 1,
+    },
+    {
+      // item1.seq == item2.seq && item1.stamp < item2.stamp
+      input: [
+        { item: { sequence: "2", dtStamp: "20150910T181048Z" } },
+        { item: { sequence: "2", dtStamp: "20150911T181048Z" } },
+      ],
+      expected: -1,
+    },
+    {
+      // item1.seq > item2.seq && item1.stamp == item2.stamp
+      input: [
+        { item: { sequence: "3", dtStamp: "20150910T181048Z" } },
+        { item: { sequence: "2", dtStamp: "20150910T181048Z" } },
+      ],
+      expected: 1,
+    },
+    {
+      // item1.seq > item2.seq && item1.stamp > item2.stamp
+      input: [
+        { item: { sequence: "3", dtStamp: "20150911T181048Z" } },
+        { item: { sequence: "2", dtStamp: "20150910T181048Z" } },
+      ],
+      expected: 1,
+    },
+    {
+      // item1.seq > item2.seq && item1.stamp < item2.stamp
+      input: [
+        { item: { sequence: "3", dtStamp: "20150910T181048Z" } },
+        { item: { sequence: "2", dtStamp: "20150911T181048Z" } },
+      ],
+      expected: 1,
+    },
+    {
+      // item1.seq < item2.seq && item1.stamp == item2.stamp
+      input: [
+        { item: { sequence: "2", dtStamp: "20150910T181048Z" } },
+        { item: { sequence: "3", dtStamp: "20150910T181048Z" } },
+      ],
+      expected: -1,
+    },
+    {
+      // item1.seq < item2.seq && item1.stamp > item2.stamp
+      input: [
+        { item: { sequence: "2", dtStamp: "20150911T181048Z" } },
+        { item: { sequence: "3", dtStamp: "20150910T181048Z" } },
+      ],
+      expected: -1,
+    },
+    {
+      // item1.seq < item2.seq && item1.stamp < item2.stamp
+      input: [
+        { item: { sequence: "2", dtStamp: "20150910T181048Z" } },
+        { item: { sequence: "3", dtStamp: "20150911T181048Z" } },
+      ],
+      expected: -1,
+    },
+  ];
+  for (let i = 1; i <= data.length; i++) {
+    let test = data[i - 1];
+    let testItems = getSeqStampTestItems(test);
+    equal(cal.itip.compare(testItems[0], testItems[1]), test.expected, "(test #" + i + ")");
+  }
+});
+
+add_task(function test_getAttendeesBySender() {
+  let data = [
+    {
+      input: {
+        attendees: [
+          { id: "mailto:user1@example.net", sentBy: null },
+          { id: "mailto:user2@example.net", sentBy: null },
+        ],
+        sender: "user1@example.net",
+      },
+      expected: ["mailto:user1@example.net"],
+    },
+    {
+      input: {
+        attendees: [
+          { id: "mailto:user1@example.net", sentBy: null },
+          { id: "mailto:user2@example.net", sentBy: null },
+        ],
+        sender: "user3@example.net",
+      },
+      expected: [],
+    },
+    {
+      input: {
+        attendees: [
+          { id: "mailto:user1@example.net", sentBy: "mailto:user3@example.net" },
+          { id: "mailto:user2@example.net", sentBy: null },
+        ],
+        sender: "user3@example.net",
+      },
+      expected: ["mailto:user1@example.net"],
+    },
+    {
+      input: {
+        attendees: [
+          { id: "mailto:user1@example.net", sentBy: null },
+          { id: "mailto:user2@example.net", sentBy: "mailto:user1@example.net" },
+        ],
+        sender: "user1@example.net",
+      },
+      expected: ["mailto:user1@example.net", "mailto:user2@example.net"],
+    },
+    {
+      input: { attendees: [], sender: "user1@example.net" },
+      expected: [],
+    },
+    {
+      input: {
+        attendees: [
+          { id: "mailto:user1@example.net", sentBy: null },
+          { id: "mailto:user2@example.net", sentBy: null },
+        ],
+        sender: "",
+      },
+      expected: [],
+    },
+    {
+      input: {
+        attendees: [
+          { id: "mailto:user1@example.net", sentBy: null },
+          { id: "mailto:user2@example.net", sentBy: null },
+        ],
+        sender: null,
+      },
+      expected: [],
+    },
+  ];
+
+  for (let i = 1; i <= data.length; i++) {
+    let test = data[i - 1];
+    let attendees = [];
+    for (let att of test.input.attendees) {
+      let attendee = new CalAttendee();
+      attendee.id = att.id;
+      if (att.sentBy) {
+        attendee.setProperty("SENT-BY", att.sentBy);
+      }
+      attendees.push(attendee);
+    }
+    let detected = [];
+    cal.itip.getAttendeesBySender(attendees, test.input.sender).forEach(att => {
+      detected.push(att.id);
+    });
+    ok(
+      detected.every(aId => test.expected.includes(aId)),
+      "(test #" + i + " ok1)"
+    );
+    ok(
+      test.expected.every(aId => detected.includes(aId)),
+      "(test #" + i + " ok2)"
+    );
+  }
+});
+
+add_task(function test_resolveDelegation() {
+  let data = [
+    {
+      input: {
+        attendee:
+          'ATTENDEE;DELEGATED-FROM="mailto:attendee2@example.net";CN="Attendee 1":mailto:at' +
+          "tendee1@example.net",
+        attendees: [
+          'ATTENDEE;DELEGATED-FROM="mailto:attendee2@example.net";CN="Attendee 1":mailto:at' +
+            "tendee1@example.net",
+          'ATTENDEE;DELEGATED-TO="mailto:attendee1@example.net";CN="Attendee 2":mailto:atte' +
+            "ndee2@example.net",
+        ],
+      },
+      expected: {
+        delegatees: "",
+        delegators: "Attendee 2 <attendee2@example.net>",
+      },
+    },
+    {
+      input: {
+        attendee:
+          'ATTENDEE;DELEGATED-FROM="mailto:attendee2@example.net":mailto:attendee1@example.net',
+        attendees: [
+          'ATTENDEE;DELEGATED-FROM="mailto:attendee2@example.net":mailto:attendee1@example.net',
+          'ATTENDEE;DELEGATED-TO="mailto:attendee1@example.net":mailto:attendee2@example.net',
+        ],
+      },
+      expected: {
+        delegatees: "",
+        delegators: "attendee2@example.net",
+      },
+    },
+    {
+      input: {
+        attendee:
+          'ATTENDEE;DELEGATED-TO="mailto:attendee2@example.net";CN="Attendee 1":mailto:atte' +
+          "ndee1@example.net",
+        attendees: [
+          'ATTENDEE;DELEGATED-TO="mailto:attendee2@example.net";CN="Attendee 1":mailto:atte' +
+            "ndee1@example.net",
+          'ATTENDEE;DELEGATED-FROM="mailto:attendee1@example.net";CN="Attendee 2":mailto:at' +
+            "tendee2@example.net",
+        ],
+      },
+      expected: {
+        delegatees: "Attendee 2 <attendee2@example.net>",
+        delegators: "",
+      },
+    },
+    {
+      input: {
+        attendee:
+          'ATTENDEE;DELEGATED-TO="mailto:attendee2@example.net":mailto:attendee1@example.net',
+        attendees: [
+          'ATTENDEE;DELEGATED-TO="mailto:attendee2@example.net":mailto:attendee1@example.net',
+          'ATTENDEE;DELEGATED-FROM="mailto:attendee1@example.net":mailto:attendee2@example.net',
+        ],
+      },
+      expected: {
+        delegatees: "attendee2@example.net",
+        delegators: "",
+      },
+    },
+    {
+      input: {
+        attendee: "ATTENDEE:mailto:attendee1@example.net",
+        attendees: [
+          "ATTENDEE:mailto:attendee1@example.net",
+          "ATTENDEE:mailto:attendee2@example.net",
+        ],
+      },
+      expected: {
+        delegatees: "",
+        delegators: "",
+      },
+    },
+    {
+      input: {
+        attendee:
+          'ATTENDEE;DELEGATED-FROM="mailto:attendee2@example.net";DELEGATED-TO="mailto:atte' +
+          'ndee3@example.net":mailto:attendee1@example.net',
+        attendees: [
+          'ATTENDEE;DELEGATED-FROM="mailto:attendee2@example.net";DELEGATED-TO="mailto:atte' +
+            'ndee3@example.net":mailto:attendee1@example.net',
+          'ATTENDEE;DELEGATED-TO="mailto:attendee1@example.net":mailto:attendee2@example.net',
+          'ATTENDEE;DELEGATED-FROM="mailto:attendee1@example.net":mailto:attendee3@example.net',
+        ],
+      },
+      expected: {
+        delegatees: "attendee3@example.net",
+        delegators: "attendee2@example.net",
+      },
+    },
+  ];
+  let i = 0;
+  for (let test of data) {
+    i++;
+    let attendees = [];
+    for (let att of test.input.attendees) {
+      let attendee = new CalAttendee();
+      attendee.icalString = att;
+      attendees.push(attendee);
+    }
+    let attendee = new CalAttendee();
+    attendee.icalString = test.input.attendee;
+    let result = cal.itip.resolveDelegation(attendee, attendees);
+    equal(result.delegatees, test.expected.delegatees, "(test #" + i + " - delegatees)");
+    equal(result.delegators, test.expected.delegators, "(test #" + i + " - delegators)");
+  }
+});
+
+/**
+ * Tests the various ways to use the getInvitedAttendee function.
+ */
+add_task(async function test_getInvitedAttendee() {
+  class MockCalendar {
+    supportsScheduling = true;
+
+    constructor(invitedAttendee) {
+      this.invitedAttendee = invitedAttendee;
+    }
+
+    getSchedulingSupport() {
+      return this;
+    }
+
+    getInvitedAttendee() {
+      return this.invitedAttendee;
+    }
+  }
+
+  let invitedAttendee = new CalAttendee();
+  invitedAttendee.id = "mailto:invited@example.com";
+
+  let calendar = new MockCalendar(invitedAttendee);
+  let event = new CalEvent(CalendarTestUtils.dedent`
+        BEGIN:VEVENT
+        CREATED:20210105T000000Z
+        DTSTAMP:20210501T000000Z
+        UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5
+        SUMMARY:Test Invitation
+        DTSTART:20210105T000000Z
+        DTEND:20210105T100000Z
+        STATUS:CONFIRMED
+        SUMMARY:Test Event
+        ORGANIZER;CN=events@example.com:mailto:events@example.com
+        ATTENDEE;CUTYPE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;PARTSTAT=ACCEPTED;
+          RSVP=TRUE;CN=invited@example.com;:mailto:invited@example.com
+        END:VEVENT
+      `);
+
+  // No calendar configured or provided.
+  Assert.ok(
+    !cal.itip.getInvitedAttendee(event),
+    "returns falsy when item has no calendar and none provided"
+  );
+
+  // No calendar configured but one provided.
+  Assert.ok(
+    cal.itip.getInvitedAttendee(event, calendar) == invitedAttendee,
+    "returns the result from the provided calendar when item has none configured"
+  );
+
+  // Calendar configured, none provided.
+  event.calendar = calendar;
+  Assert.ok(
+    cal.itip.getInvitedAttendee(event) == invitedAttendee,
+    "returns the result of the item's calendar when calendar not provided"
+  );
+
+  // Calendar configured, one provided.
+  Assert.ok(
+    !cal.itip.getInvitedAttendee(event, new MockCalendar()),
+    "returns the result of the provided calendar even if item's calendar is configured"
+  );
+
+  // Calendar does not implement nsISchedulingSupport.
+  calendar.supportsScheduling = false;
+  Assert.ok(
+    !cal.itip.getInvitedAttendee(event),
+    "returns falsy if the calendar does not indicate nsISchedulingSupport"
+  );
+
+  // X-MOZ-INVITED-ATTENDEE set on event.
+  event.setProperty("X-MOZ-INVITED-ATTENDEE", "mailto:invited@example.com");
+
+  let attendee = cal.itip.getInvitedAttendee(event);
+  Assert.ok(
+    attendee && attendee.id == "mailto:invited@example.com",
+    "returns the attendee matching X-MOZ-INVITED-ATTENDEE if set"
+  );
+
+  // X-MOZ-INVITED-ATTENDEE set to non-existent attendee
+  event.setProperty("X-MOZ-INVITED-ATTENDEE", "mailto:nobody@example.com");
+  Assert.ok(
+    !cal.itip.getInvitedAttendee(event),
+    "returns falsy for non-existent X-MOZ-INVITED-ATTENDEE"
+  );
+});
+
+/**
+ * Tests the getImipTransport function returns the correct calIItipTransport.
+ */
+add_task(function test_getImipTransport() {
+  let event = new CalEvent(CalendarTestUtils.dedent`
+        BEGIN:VEVENT
+        CREATED:20210105T000000Z
+        DTSTAMP:20210501T000000Z
+        UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5
+        SUMMARY:Test Invitation
+        DTSTART:20210105T000000Z
+        DTEND:20210105T100000Z
+        STATUS:CONFIRMED
+        SUMMARY:Test Event
+        END:VEVENT
+      `);
+
+  // Without X-MOZ-INVITED-ATTENDEE property.
+  let account1 = MailServices.accounts.createAccount();
+  let identity1 = MailServices.accounts.createIdentity();
+  identity1.email = "id1@example.com";
+  account1.addIdentity(identity1);
+
+  let calendarTransport = new CalItipEmailTransport(account1, identity1);
+  event.calendar = {
+    getProperty(key) {
+      switch (key) {
+        case "itip.transport":
+          return calendarTransport;
+        case "imip.idenity":
+          return identity1;
+        default:
+          return null;
+      }
+    },
+  };
+
+  Assert.ok(
+    cal.itip.getImipTransport(event) == calendarTransport,
+    "returns the calendar's transport when no X-MOZ-INVITED-ATTENDEE property"
+  );
+
+  // With X-MOZ-INVITED-ATTENDEE property.
+  let account2 = MailServices.accounts.createAccount();
+  let identity2 = MailServices.accounts.createIdentity();
+  identity2.email = "id2@example.com";
+  account2.addIdentity(identity2);
+  account2.incomingServer = MailServices.accounts.createIncomingServer(
+    "id2",
+    "example.com",
+    "imap"
+  );
+
+  event.setProperty("X-MOZ-INVITED-ATTENDEE", "mailto:id2@example.com");
+
+  let customTransport = cal.itip.getImipTransport(event);
+  Assert.ok(customTransport);
+
+  Assert.ok(
+    customTransport.mDefaultAccount == account2,
+    "returns a transport using an account for the X-MOZ-INVITED-ATTENDEE identity when set"
+  );
+
+  Assert.ok(
+    customTransport.mDefaultIdentity == identity2,
+    "returns a transport using the identity of the X-MOZ-INVITED-ATTENDEE property when set"
+  );
+});
diff --git a/comm/calendar/test/unit/test_l10n_utils.js b/comm/calendar/test/unit/test_l10n_utils.js
new file mode 100644
index 0000000000..98d93042fd
--- /dev/null
+++ b/comm/calendar/test/unit/test_l10n_utils.js
@@ -0,0 +1,99 @@
+/* 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 run_test() {
+  do_calendar_startup(run_next_test);
+}
+
+// tests for calL10NUtils.jsm
+/* Incomplete - still missing test coverage for:
+ * getAnyString
+ * getString
+ * getCalString
+ * getLtnString
+ * getDateFmtString
+ * formatMonth
+ */
+
+add_task(async function calendarInfo_test() {
+  let data = [
+    {
+      input: { locale: "en-US" },
+      expected: {
+        properties: ["firstDayOfWeek", "minDays", "weekend", "calendar", "locale"],
+      },
+    },
+    {
+      input: { locale: "EN-US" },
+      expected: {
+        properties: ["firstDayOfWeek", "minDays", "weekend", "calendar", "locale"],
+      },
+    },
+    {
+      input: { locale: "et" },
+      expected: {
+        properties: ["firstDayOfWeek", "minDays", "weekend", "calendar", "locale"],
+      },
+    },
+    {
+      input: { locale: null }, // this also would trigger caching tests
+      expected: {
+        properties: ["firstDayOfWeek", "minDays", "weekend", "calendar", "locale"],
+      },
+    },
+  ];
+  let useOSLocaleFormat = Services.prefs.getBoolPref("intl.regional_prefs.use_os_locales", false);
+  let osprefs = Cc["@mozilla.org/intl/ospreferences;1"].getService(Ci.mozIOSPreferences);
+  let appLocale = Services.locale.appLocalesAsBCP47[0];
+  let rsLocale = osprefs.regionalPrefsLocales[0];
+
+  let i = 0;
+  for (let test of data) {
+    i++;
+    let info = cal.l10n.calendarInfo(test.input.locale);
+    equal(
+      Object.keys(info).length,
+      test.expected.properties.length,
+      "expected number of attributes (test #" + i + ")"
+    );
+    for (let prop of test.expected.properties) {
+      ok(prop in info, prop + " exists (test #" + i + ")");
+    }
+
+    if (!test.input.locale && appLocale != rsLocale) {
+      // if aLocale is null we test with the current date and time formatting setting
+      // let's test the caching mechanism - this test section is pointless if app and
+      // OS locale are the same like probably on automation
+      Services.prefs.setBoolPref("intl.regional_prefs.use_os_locales", !useOSLocaleFormat);
+      let info2 = cal.l10n.calendarInfo();
+      equal(
+        Object.keys(info).length,
+        test.expected.properties.length,
+        "caching test - equal number of properties (test #" + i + ")"
+      );
+      for (let prop of Object.keys(info)) {
+        ok(prop in info2, "caching test - " + prop + " exists in both objects (test #" + i + ")");
+        equal(
+          info2[prop],
+          info[prop],
+          "caching test - value for " + prop + " is equal in both objects (test #" + i + ")"
+        );
+      }
+      // we reset the cache and test again - it's suffient here to find one changed property,
+      // so we use locale since that must change always in that scenario
+      // info2 = cal.l10n.calendarInfo(null, true);
+      Services.prefs.setBoolPref("intl.regional_prefs.use_os_locales", useOSLocaleFormat);
+      // This is currently disabled since the code actually doesn't reset the cache anyway.
+      // When re-enabling, be aware that macOS returns just "en" for rsLocale while other
+      // OS provide "en-US".
+      /*
+            notEqual(
+                info2.locale,
+                info.locale,
+                "caching retest - value for locale is different in both objects (test #" + i + ")"
+            );
+            */
+    }
+  }
+});
diff --git a/comm/calendar/test/unit/test_lenient_parsing.js b/comm/calendar/test/unit/test_lenient_parsing.js
new file mode 100644
index 0000000000..7d20584996
--- /dev/null
+++ b/comm/calendar/test/unit/test_lenient_parsing.js
@@ -0,0 +1,41 @@
+/* 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/. */
+
+/**
+ * Tests that ICAL.design.strict is set to false in both the main thread and
+ * the ICS parsing worker. If either or both is set to true, this will fail.
+ */
+
+add_task(async function () {
+  const item = await new Promise((resolve, reject) => {
+    Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser).parseString(
+      dedent`
+        BEGIN:VCALENDAR
+        BEGIN:VEVENT
+        SUMMARY:An event!
+        DTSTART:20240331
+        DTEND:20240331
+        END:VEVENT
+        END:VCALENDAR
+      `,
+      {
+        QueryInterface: ChromeUtils.generateQI(["calIIcsParsingListener"]),
+        onParsingComplete(rv, parser) {
+          if (Components.isSuccessCode(rv)) {
+            resolve(parser.getItems()[0]);
+          } else {
+            reject(rv);
+          }
+        },
+      }
+    );
+  });
+
+  Assert.equal(item.startDate.year, 2024);
+  Assert.equal(item.startDate.month, 2);
+  Assert.equal(item.startDate.day, 31);
+  Assert.equal(item.endDate.year, 2024);
+  Assert.equal(item.endDate.month, 2);
+  Assert.equal(item.endDate.day, 31);
+});
diff --git a/comm/calendar/test/unit/test_providers.js b/comm/calendar/test/unit/test_providers.js
new file mode 100644
index 0000000000..b800e47727
--- /dev/null
+++ b/comm/calendar/test/unit/test_providers.js
@@ -0,0 +1,426 @@
+/* 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 no-useless-concat: "off" */
+
+var icalStringArray = [
+  // Comments refer to the range defined in testGetItems().
+  // 1: one-hour event
+  "BEGIN:VEVENT\n" + "DTSTART:20020402T114500Z\n" + "DTEND:20020402T124500Z\n" + "END:VEVENT\n",
+  // 2: Test a zero-length event with DTSTART and DTEND
+  "BEGIN:VEVENT\n" + "DTSTART:20020402T000000Z\n" + "DTEND:20020402T000000Z\n" + "END:VEVENT\n",
+  // 3: Test a zero-length event with DTSTART and no DTEND
+  "BEGIN:VEVENT\n" + "DTSTART:20020402T000000Z\n" + "END:VEVENT\n",
+  // 4: Test a zero-length event with DTEND set and no  DTSTART. Invalid!
+  "BEGIN:VEVENT\n" + "DTEND:20020402T000000Z\n" + "END:VEVENT\n",
+  // 5: one-hour event that is outside the range
+  "BEGIN:VEVENT\n" + "DTSTART:20020401T114500Z\n" + "DTEND:20020401T124500Z\n" + "END:VEVENT\n",
+  // 6: one-hour event that starts outside the range and ends inside.
+  "BEGIN:VEVENT\n" + "DTSTART:20020401T114500Z\n" + "DTEND:20020402T124500Z\n" + "END:VEVENT\n",
+  // 7:  one-hour event that starts inside the range and ends outside.
+  "BEGIN:VEVENT\n" + "DTSTART:20020402T114500Z\n" + "DTEND:20020403T124500Z\n" + "END:VEVENT\n",
+  // 8: one-hour event that starts at the end of the range.
+  "BEGIN:VEVENT\n" + "DTSTART:20020403T000000Z\n" + "DTEND:20020403T124500Z\n" + "END:VEVENT\n",
+  // 9: allday event that starts at start of range and ends at end of range.
+  "BEGIN:VEVENT\n" +
+    "DTSTART;VALUE=DATE:20020402\n" +
+    "DTEND;VALUE=DATE:20020403\n" +
+    "END:VEVENT\n",
+  // 10: allday event that starts at end of range.
+  "BEGIN:VEVENT\n" +
+    "DTSTART;VALUE=DATE:20020403\n" +
+    "DTEND;VALUE=DATE:20020404\n" +
+    "END:VEVENT\n",
+  // 11: allday event that ends at start of range. See bug 333363.
+  "BEGIN:VEVENT\n" +
+    "DTSTART;VALUE=DATE:20020401\n" +
+    "DTEND;VALUE=DATE:20020402\n" +
+    "END:VEVENT\n",
+  // 12: daily recurring allday event. parent item in the range.
+  "BEGIN:VEVENT\n" +
+    "DTSTART;VALUE=DATE:20020402\n" +
+    "DTEND;VALUE=DATE:20020403\n" +
+    "RRULE:FREQ=DAILY;INTERVAL=1;COUNT=10\n" +
+    "END:VEVENT\n",
+  // 13: daily recurring allday event. First occurrence in the range.
+  "BEGIN:VEVENT\n" +
+    "DTSTART;VALUE=DATE:20020401\n" +
+    "DTEND;VALUE=DATE:20020402\n" +
+    "RRULE:FREQ=DAILY;COUNT=10\n" +
+    "END:VEVENT\n",
+  // 14: two-daily recurring allday event. Not in the range.
+  "BEGIN:VEVENT\n" +
+    "DTSTART;VALUE=DATE:20020401\n" +
+    "DTEND;VALUE=DATE:20020402\n" +
+    "RRULE:FREQ=DAILY;INTERVAL=2;COUNT=10\n" +
+    "END:VEVENT\n",
+  // 15: daily recurring one-hour event. Parent in the range.
+  "BEGIN:VEVENT\n" +
+    "DTSTART:20020402T100000Z\n" +
+    "DTEND:20020402T110000Z\n" +
+    "RRULE:FREQ=DAILY;COUNT=10\n" +
+    "END:VEVENT\n",
+  // 16: daily recurring one-hour event. Occurrence in the range.
+  "BEGIN:VEVENT\n" +
+    "DTSTART:20020401T100000Z\n" +
+    "DTEND:20020401T110000Z\n" +
+    "RRULE:FREQ=DAILY;COUNT=10\n" +
+    "END:VEVENT\n",
+  // 17: zero-length task with DTSTART and DUE set at start of range.
+  "BEGIN:VTODO\n" + "DTSTART:20020402T000000Z\n" + "DUE:20020402T000000Z\n" + "END:VTODO\n",
+  // 18: zero-length event with only DTSTART set at start of range.
+  "BEGIN:VTODO\n" + "DTSTART:20020402T000000Z\n" + "END:VTODO\n",
+  // 19: zero-length event with only DUE set at start of range.
+  "BEGIN:VTODO\n" + "DUE:20020402T000000Z\n" + "END:VTODO\n",
+  // 20: one-hour todo within the range.
+  "BEGIN:VTODO\n" + "DTSTART:20020402T110000Z\n" + "DUE:20020402T120000Z\n" + "END:VTODO\n",
+  // 21: zero-length todo that starts at end of range.
+  "BEGIN:VTODO\n" + "DTSTART:20020403T000000Z\n" + "DUE:20020403T010000Z\n" + "END:VTODO\n",
+  // 22: one-hour todo that ends at start of range.
+  "BEGIN:VTODO\n" + "DTSTART:20020401T230000Z\n" + "DUE:20020402T000000Z\n" + "END:VTODO\n",
+  // 23: daily recurring one-hour event. Parent in the range.
+  "BEGIN:VEVENT\n" +
+    "DTSTART:20020402T000000\n" +
+    "DTEND:20020402T010000\n" +
+    "RRULE:FREQ=DAILY;COUNT=10\n" +
+    "END:VEVENT\n",
+  // 24: daily recurring 24-hour event. Parent in the range.
+  "BEGIN:VEVENT\n" +
+    "DTSTART:20020402T000000\n" +
+    "DTEND:20020403T000000\n" +
+    "RRULE:FREQ=DAILY;COUNT=10\n" +
+    "END:VEVENT\n",
+  // 25: todo that has neither start nor due date set.
+  // Should be returned on every getItems() call. See bug 405459.
+  "BEGIN:VTODO\n" + "SUMMARY:Todo\n" + "END:VTODO\n",
+  // 26: todo that has neither start nor due date but
+  // a completion time set after range. See bug 405459.
+  "BEGIN:VTODO\n" + "SUMMARY:Todo\n" + "COMPLETED:20030404T000001\n" + "END:VTODO\n",
+  // 27: todo that has neither start nor due date but a
+  // completion time set in the range. See bug 405459.
+  "BEGIN:VTODO\n" + "SUMMARY:Todo\n" + "COMPLETED:20020402T120001\n" + "END:VTODO\n",
+  // 28: todo that has neither start nor due date but a
+  // completion time set before the range. See bug 405459.
+  "BEGIN:VTODO\n" + "SUMMARY:Todo\n" + "COMPLETED:20020402T000000\n" + "END:VTODO\n",
+  // 29: todo that has neither start nor due date set,
+  // has the status "COMPLETED" but no completion time. See bug 405459.
+  "BEGIN:VTODO\n" + "SUMMARY:Todo\n" + "STATUS:COMPLETED\n" + "END:VTODO\n",
+  // 30: one-hour event with duration (in the range). See bug 390492.
+  "BEGIN:VEVENT\n" + "DTSTART:20020402T114500Z\n" + "DURATION:PT1H\n" + "END:VEVENT\n",
+  // 31: one-hour event with duration (after the range). See bug 390492.
+  "BEGIN:VEVENT\n" + "DTSTART:20020403T000000Z\n" + "DURATION:PT1H\n" + "END:VEVENT\n",
+  // 32: one-hour event with duration (before the range). See bug 390492.
+  "BEGIN:VEVENT\n" + "DTSTART:20020401T230000Z\n" + "DURATION:PT1H\n" + "END:VEVENT\n",
+  // 33: one-day event with duration. Starts in the range, Ends outside. See bug 390492.
+  "BEGIN:VEVENT\n" + "DTSTART:20020402T120000Z\n" + "DURATION:P1D\n" + "END:VEVENT\n",
+  // 34: one-day event with duration. Starts before the range. Ends inside. See bug 390492.
+  "BEGIN:VEVENT\n" + "DTSTART:20020401T120000Z\n" + "DURATION:P1D\n" + "END:VEVENT\n",
+  // 35: one-day event with duration (before the range). See bug 390492.
+  "BEGIN:VEVENT\n" + "DTSTART:20020401T000000Z\n" + "DURATION:P1D\n" + "END:VEVENT\n",
+  // 36: one-day event with duration (after the range). See bug 390492.
+  "BEGIN:VEVENT\n" + "DTSTART:20020403T000000Z\n" + "DURATION:P1D\n" + "END:VEVENT\n",
+];
+
+add_task(async function testIcalData() {
+  // First entry is test number, second item is expected result for testGetItems().
+  let wantedArray = [
+    [1, 1],
+    [2, 1],
+    [3, 1],
+    [5, 0],
+    [6, 1],
+    [7, 1],
+    [8, 0],
+    [9, 1],
+    [10, 0],
+    [11, 0],
+    [12, 1],
+    [13, 1],
+    [14, 0],
+    [15, 1],
+    [16, 1],
+    [17, 1],
+    [18, 1],
+    [19, 1],
+    [20, 1],
+    [21, 0],
+    [22, 0],
+    [23, 1],
+    [24, 1],
+    [25, 1],
+    [26, 1],
+    [27, 1],
+    [28, 0],
+    [29, 1],
+    [30, 1],
+    [31, 0],
+    [32, 0],
+    [33, 1],
+    [34, 1],
+    [35, 0],
+    [36, 0],
+  ];
+
+  for (let i = 0; i < wantedArray.length; i++) {
+    let itemArray = wantedArray[i];
+    // Correct for 1 to stay in synch with test numbers.
+    let calItem = icalStringArray[itemArray[0] - 1];
+
+    let item;
+    if (calItem.search(/VEVENT/) != -1) {
+      item = createEventFromIcalString(calItem);
+    } else if (calItem.search(/VTODO/) != -1) {
+      item = createTodoFromIcalString(calItem);
+    }
+
+    print("Test " + wantedArray[i][0]);
+    await testGetItems(item, itemArray[1]);
+    await testGetItem(item);
+  }
+
+  /**
+   * Adds aItem to a calendar and performs a getItems() call using the
+   * following range:
+   *   2002/04/02 0:00 - 2002/04/03 0:00
+   * The amount of returned items is compared with expected amount (aResult).
+   * Additionally, the properties of the returned item are compared with aItem.
+   */
+  async function testGetItems(aItem, aResult) {
+    for (let calendar of [getStorageCal(), getMemoryCal()]) {
+      await checkCalendar(calendar, aItem, aResult);
+    }
+  }
+
+  async function checkCalendar(calendar, aItem, aResult) {
+    // add item to calendar
+    await calendar.addItem(aItem);
+
+    // construct range
+    let rangeStart = createDate(2002, 3, 2); // 3 = April
+    let rangeEnd = rangeStart.clone();
+    rangeEnd.day += 1;
+
+    // filter options
+    let filter =
+      Ci.calICalendar.ITEM_FILTER_TYPE_ALL |
+      Ci.calICalendar.ITEM_FILTER_CLASS_OCCURRENCES |
+      Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL;
+
+    // implement listener
+    let count = 0;
+    for await (let items of cal.iterate.streamValues(
+      calendar.getItems(filter, 0, rangeStart, rangeEnd)
+    )) {
+      if (items.length) {
+        count += items.length;
+        for (let i = 0; i < items.length; i++) {
+          // Don't check creationDate as it changed when we added the item to the database.
+          compareItemsSpecific(items[i].parentItem, aItem, [
+            "start",
+            "end",
+            "duration",
+            "title",
+            "priority",
+            "privacy",
+            "status",
+            "alarmLastAck",
+            "recurrenceStartDate",
+          ]);
+        }
+      }
+    }
+    equal(count, aResult);
+  }
+
+  /**
+   * (1) Add aItem to a calendar.
+   * The properties of the added item are compared with the passed item.
+   * (2) Perform a getItem() call.
+   * The properties of the returned item are compared with the passed item.
+   */
+  async function testGetItem(aItem) {
+    // get calendars
+    let calArray = [];
+    calArray.push(getStorageCal());
+    calArray.push(getMemoryCal());
+    for (let calendar of calArray) {
+      let count = 0;
+      let returnedItem = null;
+
+      let aDetail = await calendar.addItem(aItem);
+      compareItemsSpecific(aDetail, aItem);
+      // perform getItem() on calendar
+      returnedItem = await calendar.getItem(aDetail.id);
+      count = returnedItem ? 1 : 0;
+
+      equal(count, 1);
+      // Don't check creationDate as it changed when we added the item to the database.
+      compareItemsSpecific(returnedItem, aItem, [
+        "start",
+        "end",
+        "duration",
+        "title",
+        "priority",
+        "privacy",
+        "status",
+        "alarmLastAck",
+        "recurrenceStartDate",
+      ]);
+    }
+  }
+});
+
+add_task(async function testMetaData() {
+  async function testMetaData_(aCalendar) {
+    dump("testMetaData_() calendar type: " + aCalendar.type + "\n");
+    let event1 = createEventFromIcalString(
+      "BEGIN:VEVENT\n" + "DTSTART;VALUE=DATE:20020402\n" + "END:VEVENT\n"
+    );
+
+    event1.id = "item1";
+    await aCalendar.addItem(event1);
+
+    aCalendar.setMetaData("item1", "meta1");
+    equal(aCalendar.getMetaData("item1"), "meta1");
+    equal(aCalendar.getMetaData("unknown"), null);
+
+    let event2 = event1.clone();
+    event2.id = "item2";
+    await aCalendar.addItem(event2);
+
+    aCalendar.setMetaData("item2", "meta2-");
+    equal(aCalendar.getMetaData("item2"), "meta2-");
+
+    aCalendar.setMetaData("item2", "meta2");
+    equal(aCalendar.getMetaData("item2"), "meta2");
+
+    let ids = aCalendar.getAllMetaDataIds();
+    let values = aCalendar.getAllMetaDataValues();
+    equal(values.length, 2);
+    equal(ids.length, 2);
+    ok(ids[0] == "item1" || ids[1] == "item1");
+    ok(ids[0] == "item2" || ids[1] == "item2");
+    ok(values[0] == "meta1" || values[1] == "meta1");
+    ok(values[0] == "meta2" || values[1] == "meta2");
+
+    await aCalendar.deleteItem(event1);
+
+    equal(aCalendar.getMetaData("item1"), null);
+    ids = aCalendar.getAllMetaDataIds();
+    values = aCalendar.getAllMetaDataValues();
+    equal(values.length, 1);
+    equal(ids.length, 1);
+    ok(ids[0] == "item2");
+    ok(values[0] == "meta2");
+
+    aCalendar.deleteMetaData("item2");
+    equal(aCalendar.getMetaData("item2"), null);
+    values = aCalendar.getAllMetaDataValues();
+    ids = aCalendar.getAllMetaDataIds();
+    equal(values.length, 0);
+    equal(ids.length, 0);
+
+    aCalendar.setMetaData("item2", "meta2");
+    equal(aCalendar.getMetaData("item2"), "meta2");
+    await new Promise(resolve => {
+      aCalendar.QueryInterface(Ci.calICalendarProvider).deleteCalendar(aCalendar, {
+        onCreateCalendar: () => {},
+        onDeleteCalendar: resolve,
+      });
+    });
+    values = aCalendar.getAllMetaDataValues();
+    ids = aCalendar.getAllMetaDataIds();
+    equal(values.length, 0);
+    equal(ids.length, 0);
+
+    aCalendar.deleteMetaData("unknown"); // check graceful return
+  }
+
+  await testMetaData_(getMemoryCal());
+  await testMetaData_(getStorageCal());
+});
+
+/*
+async function testOfflineStorage(storageGetter, isRecurring) {
+    let storage = storageGetter();
+    print(`Running offline storage test for ${storage.type} calendar for ${isRecurring ? "recurring" : "normal"} item`);
+
+    let event1 = createEventFromIcalString("BEGIN:VEVENT\n" +
+                                           "DTSTART;VALUE=DATE:20020402\n" +
+                                           "DTEND;VALUE=DATE:20020403\n" +
+                                           "SUMMARY:event1\n" +
+                                           (isRecurring ? "RRULE:FREQ=DAILY;INTERVAL=1;COUNT=10\n" : "") +
+                                           "END:VEVENT\n");
+
+    event1 = await storage.addItem(event1);
+
+    // Make sure the event is really in the calendar
+    let result = await storage.getAllItems();
+    equal(result.length, 1);
+
+    // When searching for offline added items, there are none
+    let filter = Ci.calICalendar.ITEM_FILTER_ALL_ITEMS | Ci.calICalendar.ITEM_FILTER_OFFLINE_CREATED;
+    result = await storage.getItems(filter, 0, null, null);
+    equal(result.length, 0);
+
+    // Mark the item as offline added
+    await storage.addOfflineItem(event1);
+
+    // Now there should be an offline item
+    result = await storage.getItems(filter, 0, null, null);
+    equal(result.length, 1);
+
+    let event2 = event1.clone();
+    event2.title = "event2";
+
+    event2 = await storage.modifyItem(event2, event1);
+
+    await storage.modifyOfflineItem(event2);
+
+    // The flag should still be offline added, as it was already marked as such
+    filter = Ci.calICalendar.ITEM_FILTER_ALL_ITEMS | Ci.calICalendar.ITEM_FILTER_OFFLINE_CREATED;
+    result = await storage.getItems(filter, 0, null, null);
+    equal(result.length, 1);
+
+    // Reset the flag
+    await storage.resetItemOfflineFlag(event2);
+
+    // No more offline items after resetting the flag
+    filter = Ci.calICalendar.ITEM_FILTER_ALL_ITEMS | Ci.calICalendar.ITEM_FILTER_OFFLINE_CREATED;
+    result = await storage.getItems(filter, 0, null, null);
+    equal(result.length, 0);
+
+    // Setting modify flag without one set should actually set that flag
+    await storage.modifyOfflineItem(event2);
+    filter = Ci.calICalendar.ITEM_FILTER_ALL_ITEMS | Ci.calICalendar.ITEM_FILTER_OFFLINE_CREATED;
+    result = await storage.getItems(filter, 0, null, null);
+    equal(result.length, 0);
+
+    filter = Ci.calICalendar.ITEM_FILTER_ALL_ITEMS | Ci.calICalendar.ITEM_FILTER_OFFLINE_MODIFIED;
+    result = await storage.getItems(filter, 0, null, null);
+    equal(result.length, 1);
+
+    // Setting the delete flag should modify the flag accordingly
+    await storage.deleteOfflineItem(event2);
+    filter = Ci.calICalendar.ITEM_FILTER_ALL_ITEMS | Ci.calICalendar.ITEM_FILTER_OFFLINE_MODIFIED;
+    result = await storage.getItems(filter, 0, null, null);
+    equal(result.length, 0);
+
+    filter = Ci.calICalendar.ITEM_FILTER_ALL_ITEMS | Ci.calICalendar.ITEM_FILTER_OFFLINE_DELETED;
+    result = await storage.getItems(filter, 0, null, null);
+    equal(result.length, 1);
+
+    // Setting the delete flag on an offline added item should remove it
+    await storage.resetItemOfflineFlag(event2);
+    await storage.addOfflineItem(event2);
+    await storage.deleteOfflineItem(event2);
+    result = await storage.getItemsAsArray(Ci.calICalendar.ITEM_FILTER_ALL_ITEMS, 0, null, null);
+    equal(result.length, 0);
+}
+
+add_task(testOfflineStorage.bind(null, () => getMemoryCal(), false));
+add_task(testOfflineStorage.bind(null, () => getStorageCal(), false));
+add_task(testOfflineStorage.bind(null, () => getMemoryCal(), true));
+add_task(testOfflineStorage.bind(null, () => getStorageCal(), true));
+*/
diff --git a/comm/calendar/test/unit/test_recur.js b/comm/calendar/test/unit/test_recur.js
new file mode 100644
index 0000000000..32033d5b85
--- /dev/null
+++ b/comm/calendar/test/unit/test_recur.js
@@ -0,0 +1,1361 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalRecurrenceInfo: "resource:///modules/CalRecurrenceInfo.jsm",
+});
+
+function makeEvent(str) {
+  return createEventFromIcalString("BEGIN:VEVENT\n" + str + "END:VEVENT");
+}
+
+function run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  test_interface();
+  test_rrule_interface();
+  test_rules();
+  test_failures();
+  test_limit();
+  test_startdate_change();
+  test_idchange();
+  test_rrule_icalstring();
+  test_immutable();
+  test_icalComponent();
+}
+
+function test_rules() {
+  function check_recur(event, expected, endDate, ignoreNextOccCheck) {
+    dump("Checking '" + event.getProperty("DESCRIPTION") + "'\n");
+
+    // Immutability is required for testing the recurrenceEndDate property.
+    event.makeImmutable();
+
+    // Get recurrence dates
+    let start = createDate(1990, 0, 1);
+    let end = createDate(2020, 0, 1);
+    let recdates = event.recurrenceInfo.getOccurrenceDates(start, end, 0);
+    let occurrences = event.recurrenceInfo.getOccurrences(start, end, 0);
+
+    // Check number of items
+    dump("Expected " + expected.length + " occurrences\n");
+    dump("Got: " + recdates.map(x => x.toString()) + "\n");
+    equal(recdates.length, expected.length);
+    let fmt = cal.dtz.formatter;
+
+    for (let i = 0; i < expected.length; i++) {
+      // Check each date
+      let expectedDate = cal.createDateTime(expected[i]);
+      dump(
+        "Expecting instance at " + expectedDate + "(" + fmt.dayName(expectedDate.weekday) + ")\n"
+      );
+      dump("Recdate:");
+      equal(recdates[i].icalString, expected[i]);
+
+      // Make sure occurrences are correct
+      dump("Occurrence:");
+      occurrences[i].QueryInterface(Ci.calIEvent);
+      equal(occurrences[i].startDate.icalString, expected[i]);
+
+      if (ignoreNextOccCheck) {
+        continue;
+      }
+
+      // Make sure getNextOccurrence works correctly
+      let nextOcc = event.recurrenceInfo.getNextOccurrence(recdates[i]);
+      if (expected.length > i + 1) {
+        notEqual(nextOcc, null);
+        dump("Checking next occurrence: " + expected[i + 1] + "\n");
+        nextOcc.QueryInterface(Ci.calIEvent);
+        equal(nextOcc.startDate.icalString, expected[i + 1]);
+      } else {
+        dump("Expecting no more occurrences, found " + (nextOcc ? nextOcc.startDate : null) + "\n");
+        equal(nextOcc, null);
+      }
+
+      // Make sure getPreviousOccurrence works correctly
+      let prevOcc = event.recurrenceInfo.getPreviousOccurrence(recdates[i]);
+      if (i > 0) {
+        dump(
+          "Checking previous occurrence: " +
+            expected[i - 1] +
+            ", found " +
+            (prevOcc ? prevOcc.startDate : prevOcc) +
+            "\n"
+        );
+        notEqual(prevOcc, null);
+        prevOcc.QueryInterface(Ci.calIEvent);
+        equal(prevOcc.startDate.icalString, expected[i - 1]);
+      } else {
+        dump(
+          "Expecting no previous occurrences, found " +
+            (prevOcc ? prevOcc.startDate : prevOcc) +
+            "\n"
+        );
+        equal(prevOcc, null);
+      }
+    }
+
+    if (typeof endDate == "string") {
+      endDate = cal.createDateTime(endDate).nativeTime;
+    }
+    equal(event.recurrenceInfo.recurrenceEndDate, endDate);
+
+    //  Make sure recurrenceInfo.clone works correctly
+    test_clone(event);
+  }
+
+  // Test specific items/rules
+  check_recur(
+    makeEvent(
+      "DESCRIPTION:Repeat every tuesday and wednesday starting " +
+        "Tue 2nd April 2002\n" +
+        "RRULE:FREQ=WEEKLY;INTERVAL=1;COUNT=6;BYDAY=TU,WE\n" +
+        "DTSTART:20020402T114500\n" +
+        "DTEND:20020402T124500\n"
+    ),
+    [
+      "20020402T114500",
+      "20020403T114500",
+      "20020409T114500",
+      "20020410T114500",
+      "20020416T114500",
+      "20020417T114500",
+    ],
+    "20020417T124500"
+  );
+
+  check_recur(
+    makeEvent(
+      "DESCRIPTION:Repeat every thursday starting Tue 2nd April 2002\n" +
+        "RRULE:FREQ=WEEKLY;INTERVAL=1;COUNT=6;BYDAY=TH\n" +
+        "DTSTART:20020402T114500\n" +
+        "DTEND:20020402T124500\n"
+    ),
+    [
+      "20020402T114500", // DTSTART part of the resulting set
+      "20020404T114500",
+      "20020411T114500",
+      "20020418T114500",
+      "20020425T114500",
+      "20020502T114500",
+      "20020509T114500",
+    ],
+    "20020509T124500"
+  );
+
+  // Bug 469840 -  Recurring Sundays incorrect
+  check_recur(
+    makeEvent(
+      "DESCRIPTION:RRULE:FREQ=WEEKLY;INTERVAL=2;COUNT=6;BYDAY=WE,SA,SU with DTSTART:20081217T133000\n" +
+        "RRULE:FREQ=WEEKLY;INTERVAL=2;COUNT=6;BYDAY=WE,SA,SU\n" +
+        "DTSTART:20081217T133000\n" +
+        "DTEND:20081217T143000\n"
+    ),
+    [
+      "20081217T133000",
+      "20081220T133000",
+      "20081221T133000",
+      "20081231T133000",
+      "20090103T133000",
+      "20090104T133000",
+    ],
+    "20090104T143000"
+  );
+
+  check_recur(
+    makeEvent(
+      "DESCRIPTION:RRULE:FREQ=WEEKLY;INTERVAL=2;COUNT=6;WKST=SU;BYDAY=WE,SA,SU with DTSTART:20081217T133000\n" +
+        "RRULE:FREQ=WEEKLY;INTERVAL=2;COUNT=6;WKST=SU;BYDAY=WE,SA,SU\n" +
+        "DTSTART:20081217T133000\n" +
+        "DTEND:20081217T143000\n"
+    ),
+    [
+      "20081217T133000",
+      "20081220T133000",
+      "20081228T133000",
+      "20081231T133000",
+      "20090103T133000",
+      "20090111T133000",
+    ],
+    "20090111T143000"
+  );
+
+  // bug 353797: occurrences for repeating all day events should stay "all-day"
+  check_recur(
+    makeEvent(
+      "DESCRIPTION:Allday repeat every thursday starting Tue 2nd April 2002\n" +
+        "RRULE:FREQ=WEEKLY;INTERVAL=1;COUNT=3;BYDAY=TH\n" +
+        "DTSTART;VALUE=DATE:20020404\n" +
+        "DTEND;VALUE=DATE:20020405\n"
+    ),
+    ["20020404", "20020411", "20020418"],
+    "20020419"
+  );
+
+  /* Test disabled, because BYWEEKNO is known to be broken
+    check_recur(makeEvent("DESCRIPTION:Monday of week number 20 (where the default start of the week is Monday)\n" +
+                         "RRULE:FREQ=YEARLY;INTERVAL=1;COUNT=6;BYDAY=MO;BYWEEKNO=20\n" +
+                         "DTSTART:19970512T090000",
+                         ["19970512T090000", "19980511T090000", "19990517T090000" +
+                          "20000515T090000", "20010514T090000", "20020513T090000"]);
+    */
+
+  // bug 899326: Recurrences with BYMONTHDAY=X,X,31 don't show at all in months with less than 31 days
+  check_recur(
+    makeEvent(
+      "DESCRIPTION:Every 11th & 31st of every Month\n" +
+        "RRULE:FREQ=MONTHLY;COUNT=6;BYMONTHDAY=11,31\n" +
+        "DTSTART:20130731T160000\n" +
+        "DTEND:20130731T170000\n"
+    ),
+    [
+      "20130731T160000",
+      "20130811T160000",
+      "20130831T160000",
+      "20130911T160000",
+      "20131011T160000",
+      "20131031T160000",
+    ],
+    "20131031T170000"
+  );
+
+  // bug 899770: Monthly Recurrences with BYDAY and BYMONTHDAY with more than 2 dates are not working
+  check_recur(
+    makeEvent(
+      "DESCRIPTION:Every WE & SA the 6th, 20th & 31st\n" +
+        "RRULE:FREQ=MONTHLY;COUNT=6;BYDAY=WE,SA;BYMONTHDAY=6,20,31\n" +
+        "DTSTART:20130706T160000\n" +
+        "DTEND:20130706T170000\n"
+    ),
+    [
+      "20130706T160000",
+      "20130720T160000",
+      "20130731T160000",
+      "20130831T160000",
+      "20131106T160000",
+      "20131120T160000",
+    ],
+    "20131120T170000"
+  );
+
+  check_recur(
+    makeEvent(
+      "DESCRIPTION:Every day, use exdate to exclude the second day\n" +
+        "RRULE:FREQ=DAILY;COUNT=3\n" +
+        "DTSTART:20020402T114500Z\n" +
+        "EXDATE:20020403T114500Z\n"
+    ),
+    ["20020402T114500Z", "20020404T114500Z"],
+    "20020404T114500"
+  );
+
+  // test for issue 734245
+  check_recur(
+    makeEvent(
+      "DESCRIPTION:Every day, use exdate of type DATE to exclude the second day\n" +
+        "RRULE:FREQ=DAILY;COUNT=3\n" +
+        "DTSTART:20020402T114500Z\n" +
+        "EXDATE;VALUE=DATE:20020403\n"
+    ),
+    ["20020402T114500Z", "20020404T114500Z"],
+    "20020404T114500"
+  );
+
+  check_recur(
+    makeEvent(
+      "DESCRIPTION:Use EXDATE to eliminate the base event\n" +
+        "RRULE:FREQ=DAILY;COUNT=1\n" +
+        "DTSTART:20020402T114500Z\n" +
+        "EXDATE:20020402T114500Z\n"
+    ),
+    [],
+    -9223372036854775000
+  );
+
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "UID:123\n" +
+        "DESCRIPTION:Every day, exception put on exdated day\n" +
+        "RRULE:FREQ=DAILY;COUNT=3\n" +
+        "DTSTART:20020402T114500Z\n" +
+        "EXDATE:20020403T114500Z\n" +
+        "END:VEVENT\n" +
+        "BEGIN:VEVENT\n" +
+        "DTSTART:20020403T114500Z\n" +
+        "UID:123\n" +
+        "RECURRENCE-ID:20020404T114500Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    ["20020402T114500Z", "20020403T114500Z"],
+    "20020403T114500",
+    true
+  ); // ignore next occ check, bug 455490
+
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "UID:123\n" +
+        "DESCRIPTION:Every day, exception put on exdated start day\n" +
+        "RRULE:FREQ=DAILY;COUNT=3\n" +
+        "DTSTART:20020402T114500Z\n" +
+        "EXDATE:20020402T114500Z\n" +
+        "END:VEVENT\n" +
+        "BEGIN:VEVENT\n" +
+        "DTSTART:20020402T114500Z\n" +
+        "UID:123\n" +
+        "RECURRENCE-ID:20020404T114500Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    ["20020402T114500Z", "20020403T114500Z"],
+    "20020403T114500",
+    true /* ignore next occ check, bug 455490 */
+  );
+
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Repeat Daily on weekdays with UNTIL\n" +
+        "RRULE:FREQ=DAILY;UNTIL=20111217T220000Z;BYDAY=MO,TU,WE,TH,FR\n" +
+        "DTSTART:20111212T220000Z\n" +
+        "DTEND:20111212T230000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20111212T220000Z",
+      "20111213T220000Z",
+      "20111214T220000Z",
+      "20111215T220000Z",
+      "20111216T220000Z",
+    ],
+    "20111216T230000",
+    false
+  );
+
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Repeat Daily on weekdays with UNTIL and exception\n" +
+        "RRULE:FREQ=DAILY;UNTIL=20111217T220000Z;BYDAY=MO,TU,WE,TH,FR\n" +
+        "EXDATE:20111214T220000Z\n" +
+        "DTSTART:20111212T220000Z\n" +
+        "DTEND:20111212T230000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    ["20111212T220000Z", "20111213T220000Z", "20111215T220000Z", "20111216T220000Z"],
+    "20111216T230000",
+    false
+  );
+
+  // Bug 958978: Yearly recurrence, the last day of a specified month.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Repeat Yearly the last day of February\n" +
+        "RRULE:FREQ=YEARLY;COUNT=6;BYMONTHDAY=-1;BYMONTH=2\n" +
+        "DTSTART:20140228T220000Z\n" +
+        "DTEND:20140228T230000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20140228T220000Z",
+      "20150228T220000Z",
+      "20160229T220000Z",
+      "20170228T220000Z",
+      "20180228T220000Z",
+      "20190228T220000Z",
+    ],
+    "20190228T230000",
+    false
+  );
+
+  // Bug 958978: Yearly recurrence, the last day of a not specified month.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Repeat Yearly the last day of April without BYMONTH=4 in the rule\n" +
+        "RRULE:FREQ=YEARLY;COUNT=6;BYMONTHDAY=-1\n" +
+        "DTSTART:20140430T220000Z\n" +
+        "DTEND:20140430T230000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20140430T220000Z",
+      "20150430T220000Z",
+      "20160430T220000Z",
+      "20170430T220000Z",
+      "20180430T220000Z",
+      "20190430T220000Z",
+    ],
+    "20190430T230000",
+    false
+  );
+
+  // Bug 958978 - Check a yearly recurrence on every WE and FR of January and March
+  //              (more BYMONTH and more BYDAY).
+  // Check for the occurrences in the first year.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Repeat Yearly every WE and FR of January and March (more BYMONTH and more BYDAY)\n" +
+        "RRULE:FREQ=YEARLY;COUNT=18;BYMONTH=1,3;BYDAY=WE,FR\n" +
+        "DTSTART:20140101T150000Z\n" +
+        "DTEND:20140101T160000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20140101T150000Z",
+      "20140103T150000Z",
+      "20140108T150000Z",
+      "20140110T150000Z",
+      "20140115T150000Z",
+      "20140117T150000Z",
+      "20140122T150000Z",
+      "20140124T150000Z",
+      "20140129T150000Z",
+      "20140131T150000Z",
+      "20140305T150000Z",
+      "20140307T150000Z",
+      "20140312T150000Z",
+      "20140314T150000Z",
+      "20140319T150000Z",
+      "20140321T150000Z",
+      "20140326T150000Z",
+      "20140328T150000Z",
+    ],
+    "20140328T160000",
+    false
+  );
+
+  // Bug 958978 - Check a yearly recurrence every day of January (BYMONTH and more BYDAY).
+  // Check for all the occurrences in the first year.
+  let expectedDates = [];
+  for (let i = 1; i < 32; i++) {
+    expectedDates.push("201401" + (i < 10 ? "0" + i : i) + "T150000Z");
+  }
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Yearly, every day of January (one BYMONTH and more BYDAY)\n" +
+        "RRULE:FREQ=YEARLY;COUNT=31;BYMONTH=1;BYDAY=SU,MO,TU,WE,TH,FR,SA\n" +
+        "DTSTART:20140101T150000Z\n" +
+        "DTEND:20140101T160000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    expectedDates,
+    "20140131T160000",
+    false
+  );
+
+  // Bug 958974 - Monthly recurrence every WE, FR and the third MO (monthly with more bydays).
+  // Check the occurrences in the first month until the week with the first monday of the rule.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Repeat Monthly every Wednesday, Friday and the third Monday\n" +
+        "RRULE:FREQ=MONTHLY;COUNT=8;BYDAY=3MO,WE,FR\n" +
+        "DTSTART:20150102T080000Z\n" +
+        "DTEND:20150102T090000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20150102T080000Z",
+      "20150107T080000Z",
+      "20150109T080000Z",
+      "20150114T080000Z",
+      "20150116T080000Z",
+      "20150119T080000Z",
+      "20150121T080000Z",
+      "20150123T080000Z",
+    ],
+    "20150123T090000",
+    false
+  );
+
+  // Bug 419490 - Monthly recurrence, the fifth Saturday starting from February.
+  // Check a monthly rule that specifies a day that is not part of the month
+  // the events starts in.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Repeat Monthly the fifth Saturday\n" +
+        "RRULE:FREQ=MONTHLY;COUNT=6;BYDAY=5SA\n" +
+        "DTSTART:20150202T080000Z\n" +
+        "DTEND:20150202T090000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20150202T080000Z",
+      "20150530T080000Z",
+      "20150829T080000Z",
+      "20151031T080000Z",
+      "20160130T080000Z",
+      "20160430T080000Z",
+      "20160730T080000Z",
+    ],
+    "20160730T090000",
+    false
+  );
+
+  // Bug 419490 - Monthly recurrence, the fifth Wednesday every two months starting from February.
+  // Check a monthly rule that specifies a day that is not part of the month
+  // the events starts in.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Repeat Monthly the fifth Friday every two months\n" +
+        "RRULE:FREQ=MONTHLY;INTERVAL=2;COUNT=6;BYDAY=5FR\n" +
+        "DTSTART:20150202T080000Z\n" +
+        "DTEND:20150202T090000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20150202T080000Z",
+      "20151030T080000Z",
+      "20160429T080000Z",
+      "20161230T080000Z",
+      "20170630T080000Z",
+      "20171229T080000Z",
+      "20180629T080000Z",
+    ],
+    "20180629T090000",
+    false
+  );
+
+  // Bugs 419490, 958974 - Monthly recurrence, the 2nd Monday, 5th Wednesday and the 5th to last Saturday every month starting from February.
+  // Check a monthly rule that specifies a day that is not part of the month
+  // the events starts in with positive and negative position along with other byday.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Repeat Monthly the 2nd Monday, 5th Wednesday and the 5th to last Saturday every month\n" +
+        "RRULE:FREQ=MONTHLY;COUNT=7;BYDAY=2MO,-5WE,5SA\n" +
+        "DTSTART:20150401T080000Z\n" +
+        "DTEND:20150401T090000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20150401T080000Z",
+      "20150413T080000Z",
+      "20150511T080000Z",
+      "20150530T080000Z",
+      "20150608T080000Z",
+      "20150701T080000Z",
+      "20150713T080000Z",
+    ],
+    "20150713T090000",
+    false
+  );
+
+  // Bug 1146500 - Monthly recurrence, every MO and FR when are odd days starting from the 1st of March.
+  // Check the first occurrence when we have BYDAY along with BYMONTHDAY.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Monthly recurrence, every MO and FR when are odd days starting from the 1st of March\n" +
+        "RRULE:FREQ=MONTHLY;BYDAY=MO,FR;BYMONTHDAY=1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31;COUNT=4\n" +
+        "DTSTART:20150301T080000Z\n" +
+        "DTEND:20150301T090000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20150301T080000Z",
+      "20150309T080000Z",
+      "20150313T080000Z",
+      "20150323T080000Z",
+      "20150327T080000Z",
+    ],
+    "20150327T090000",
+    false
+  );
+
+  // Bug 1146500 - Monthly recurrence, every MO and FR when are odd days starting from the 1st of April.
+  // Check the first occurrence when we have BYDAY along with BYMONTHDAY.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Monthly recurrence, every MO and FR when are odd days starting from the 1st of March\n" +
+        "RRULE:FREQ=MONTHLY;BYDAY=MO,FR;BYMONTHDAY=1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31;COUNT=4\n" +
+        "DTSTART:20150401T080000Z\n" +
+        "DTEND:20150401T090000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20150401T080000Z",
+      "20150403T080000Z",
+      "20150413T080000Z",
+      "20150417T080000Z",
+      "20150427T080000Z",
+    ],
+    "20150427T090000",
+    false
+  );
+
+  // Bug 1146500 - Monthly recurrence, every MO and FR when are odd days starting from the 1st of April.
+  // Check the first occurrence when we have BYDAY along with BYMONTHDAY.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Monthly recurrence, every MO and FR when are odd days starting from the 1st of March\n" +
+        "RRULE:FREQ=MONTHLY;BYDAY=MO,SA;BYMONTHDAY=1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31;COUNT=4\n" +
+        "DTSTART:20150401T080000Z\n" +
+        "DTEND:20150401T090000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20150401T080000Z",
+      "20150411T080000Z",
+      "20150413T080000Z",
+      "20150425T080000Z",
+      "20150427T080000Z",
+    ],
+    "20150427T090000",
+    false
+  );
+
+  // Bug 1146500 - Monthly every SU and FR when are odd days starting from 28 of February (BYDAY and BYMONTHDAY).
+  // Check the first occurrence when we have BYDAY along with BYMONTHDAY.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Monthly recurrence, every SU and FR when are odd days starting from the 1st of March\n" +
+        "RRULE:FREQ=MONTHLY;BYDAY=SU,FR;BYMONTHDAY=1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31;COUNT=9\n" +
+        "DTSTART:20150228T080000Z\n" +
+        "DTEND:20150228T090000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20150228T080000Z",
+      "20150301T080000Z",
+      "20150313T080000Z",
+      "20150315T080000Z",
+      "20150327T080000Z",
+      "20150329T080000Z",
+      "20150403T080000Z",
+      "20150405T080000Z",
+      "20150417T080000Z",
+      "20150419T080000Z",
+    ],
+    "20150419T090000",
+    false
+  );
+
+  // Bug 1103187 - Monthly recurrence with only MONTHLY tag in the rule. Recurrence day taken
+  // from the start date. Check four occurrences.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Only Monthly recurrence\n" +
+        "RRULE:FREQ=MONTHLY;COUNT=4\n" +
+        "DTSTART:20160404T080000Z\n" +
+        "DTEND:20160404T090000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    ["20160404T080000Z", "20160504T080000Z", "20160604T080000Z", "20160704T080000Z"],
+    "20160704T090000",
+    false
+  );
+
+  // Bug 1265554 - Monthly recurrence with only MONTHLY tag in the rule. Recurrence on the 31st
+  // of the month. Check for 6 occurrences.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Only Monthly recurrence, the 31st\n" +
+        "RRULE:FREQ=MONTHLY;COUNT=6\n" +
+        "DTSTART:20160131T150000Z\n" +
+        "DTEND:20160131T160000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20160131T150000Z",
+      "20160331T150000Z",
+      "20160531T150000Z",
+      "20160731T150000Z",
+      "20160831T150000Z",
+      "20161031T150000Z",
+    ],
+    "20161031T160000",
+    false
+  );
+
+  // Bug 1265554 - Monthly recurrence with only MONTHLY tag in the rule. Recurrence on the 31st
+  // of the month every two months. Check for 6 occurrences.
+  check_recur(
+    createEventFromIcalString(
+      "BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+        "DESCRIPTION:Only Monthly recurrence, the 31st every 2 months\n" +
+        "RRULE:FREQ=MONTHLY;INTERVAL=2;COUNT=6\n" +
+        "DTSTART:20151231T150000Z\n" +
+        "DTEND:20151231T160000Z\n" +
+        "END:VEVENT\nEND:VCALENDAR\n"
+    ),
+    [
+      "20151231T150000Z",
+      "20160831T150000Z",
+      "20161031T150000Z",
+      "20161231T150000Z",
+      "20170831T150000Z",
+      "20171031T150000Z",
+    ],
+    "20171031T160000",
+    false
+  );
+
+  let item, occ1;
+  item = makeEvent(
+    "DESCRIPTION:occurrence on day 1 moved between the occurrences " +
+      "on days 2 and 3\n" +
+      "RRULE:FREQ=DAILY;COUNT=3\n" +
+      "DTSTART:20020402T114500Z\n"
+  );
+  occ1 = item.recurrenceInfo.getOccurrenceFor(createDate(2002, 3, 2, true, 11, 45, 0));
+  occ1.QueryInterface(Ci.calIEvent);
+  occ1.startDate = createDate(2002, 3, 3, true, 12, 0, 0);
+  item.recurrenceInfo.modifyException(occ1, true);
+  check_recur(
+    item,
+    ["20020403T114500Z", "20020403T120000Z", "20020404T114500Z"],
+    "20020404T114500"
+  );
+
+  item = makeEvent(
+    "DESCRIPTION:occurrence on day 1 moved between the occurrences " +
+      "on days 2 and 3, EXDATE on day 2\n" +
+      "RRULE:FREQ=DAILY;COUNT=3\n" +
+      "DTSTART:20020402T114500Z\n" +
+      "EXDATE:20020403T114500Z\n"
+  );
+  occ1 = item.recurrenceInfo.getOccurrenceFor(createDate(2002, 3, 2, true, 11, 45, 0));
+  occ1.QueryInterface(Ci.calIEvent);
+  occ1.startDate = createDate(2002, 3, 3, true, 12, 0, 0);
+  item.recurrenceInfo.modifyException(occ1, true);
+  check_recur(item, ["20020403T120000Z", "20020404T114500Z"], "20020404T114500");
+
+  item = makeEvent(
+    "DESCRIPTION:all occurrences have exceptions\n" +
+      "RRULE:FREQ=DAILY;COUNT=2\n" +
+      "DTSTART:20020402T114500Z\n"
+  );
+  occ1 = item.recurrenceInfo.getOccurrenceFor(createDate(2002, 3, 2, true, 11, 45, 0));
+  occ1.QueryInterface(Ci.calIEvent);
+  occ1.startDate = createDate(2002, 3, 2, true, 12, 0, 0);
+  item.recurrenceInfo.modifyException(occ1, true);
+  let occ2 = item.recurrenceInfo.getOccurrenceFor(createDate(2002, 3, 3, true, 11, 45, 0));
+  occ2.QueryInterface(Ci.calIEvent);
+  occ2.startDate = createDate(2002, 3, 3, true, 12, 0, 0);
+  item.recurrenceInfo.modifyException(occ2, true);
+  check_recur(item, ["20020402T120000Z", "20020403T120000Z"], "20020403T114500");
+
+  item = makeEvent(
+    "DESCRIPTION:rdate and exception before the recurrence start date\n" +
+      "RRULE:FREQ=DAILY;COUNT=2\n" +
+      "DTSTART:20020402T114500Z\n" +
+      "RDATE:20020401T114500Z\n"
+  );
+  occ1 = item.recurrenceInfo.getOccurrenceFor(createDate(2002, 3, 2, true, 11, 45, 0));
+  occ1.QueryInterface(Ci.calIEvent);
+  occ1.startDate = createDate(2002, 2, 30, true, 11, 45, 0);
+  item.recurrenceInfo.modifyException(occ1, true);
+  check_recur(
+    item,
+    ["20020330T114500Z", "20020401T114500Z", "20020403T114500Z"],
+    "20020403T114500"
+  );
+
+  item = makeEvent(
+    "DESCRIPTION:bug 734245, an EXDATE of type DATE shall also match a DTSTART of type DATE-TIME\n" +
+      "RRULE:FREQ=DAILY;COUNT=3\n" +
+      "DTSTART:20020401T114500Z\n" +
+      "EXDATE;VALUE=DATE:20020402\n"
+  );
+  check_recur(item, ["20020401T114500Z", "20020403T114500Z"], "20020403T114500");
+
+  item = makeEvent(
+    "DESCRIPTION:EXDATE with a timezone\n" +
+      "RRULE:FREQ=DAILY;COUNT=3\n" +
+      "DTSTART;TZID=Europe/Berlin:20020401T114500\n" +
+      "EXDATE;TZID=Europe/Berlin:20020402T114500\n"
+  );
+  check_recur(item, ["20020401T114500", "20020403T114500"], "20020403T094500");
+
+  // Unsupported SECONDLY FREQ value.
+  item = makeEvent(
+    "DESCRIPTION:bug 1770984\nRRULE:FREQ=SECONDLY;COUNT=60\nDTSTART:20220606T114500Z\n"
+  );
+  check_recur(item, [], "20220606T114500Z");
+
+  // Unsupported MINUTELY FREQ value.
+  item = makeEvent(
+    "DESCRIPTION:bug 1770984\nRRULE:FREQ=MINUTELY;COUNT=60\nDTSTART:20220606T114500Z\n"
+  );
+  check_recur(item, [], "20220606T114500Z");
+}
+
+function test_limit() {
+  let item = makeEvent(
+    "RRULE:FREQ=DAILY;COUNT=3\n" +
+      "UID:1\n" +
+      "DTSTART:20020401T114500\n" +
+      "DTEND:20020401T124500\n"
+  );
+  dump("ics: " + item.icalString + "\n");
+
+  let start = createDate(1990, 0, 1);
+  let end = createDate(2020, 0, 1);
+  let recdates = item.recurrenceInfo.getOccurrenceDates(start, end, 0);
+  let occurrences = item.recurrenceInfo.getOccurrences(start, end, 0);
+
+  equal(recdates.length, 3);
+  equal(occurrences.length, 3);
+
+  recdates = item.recurrenceInfo.getOccurrenceDates(start, end, 2);
+  occurrences = item.recurrenceInfo.getOccurrences(start, end, 2);
+
+  equal(recdates.length, 2);
+  equal(occurrences.length, 2);
+
+  recdates = item.recurrenceInfo.getOccurrenceDates(start, end, 9);
+  occurrences = item.recurrenceInfo.getOccurrences(start, end, 9);
+
+  equal(recdates.length, 3);
+  equal(occurrences.length, 3);
+}
+
+function test_clone(event) {
+  let oldRecurItems = event.recurrenceInfo.getRecurrenceItems();
+  let cloned = event.recurrenceInfo.clone();
+  let newRecurItems = cloned.getRecurrenceItems();
+
+  // Check number of recurrence items
+  equal(oldRecurItems.length, newRecurItems.length);
+
+  for (let i = 0; i < oldRecurItems.length; i++) {
+    // Check if recurrence item cloned correctly
+    equal(oldRecurItems[i].icalProperty.icalString, newRecurItems[i].icalProperty.icalString);
+  }
+}
+
+function test_interface() {
+  let item = makeEvent(
+    "DTSTART:20020402T114500Z\n" +
+      "DTEND:20020402T124500Z\n" +
+      "RRULE:FREQ=WEEKLY;COUNT=6;BYDAY=TU,WE\r\n" +
+      "EXDATE:20020403T114500Z\r\n" +
+      "RDATE:20020401T114500Z\r\n"
+  );
+
+  let rinfo = item.recurrenceInfo;
+  ok(cal.data.compareObjects(rinfo.item, item, Ci.calIEvent));
+
+  // getRecurrenceItems
+  let ritems = rinfo.getRecurrenceItems();
+  equal(ritems.length, 3);
+
+  let checkritems = new Map(
+    ritems.map(ritem => [ritem.icalProperty.propertyName, ritem.icalProperty])
+  );
+  let rparts = new Map(
+    checkritems
+      .get("RRULE")
+      .value.split(";")
+      .map(value => value.split("=", 2))
+  );
+  equal(rparts.size, 3);
+  equal(rparts.get("FREQ"), "WEEKLY");
+  equal(rparts.get("COUNT"), "6");
+  equal(rparts.get("BYDAY"), "TU,WE");
+  equal(checkritems.get("EXDATE").value, "20020403T114500Z");
+  equal(checkritems.get("RDATE").value, "20020401T114500Z");
+
+  // setRecurrenceItems
+  let newRItems = [cal.createRecurrenceRule(), cal.createRecurrenceDate()];
+
+  newRItems[0].type = "DAILY";
+  newRItems[0].interval = 1;
+  newRItems[0].count = 1;
+  newRItems[1].isNegative = true;
+  newRItems[1].date = cal.createDateTime("20020404T114500Z");
+
+  rinfo.setRecurrenceItems(newRItems);
+  let itemString = item.icalString;
+
+  equal(itemString.match(/RRULE:[A-Z=,]*FREQ=WEEKLY/), null);
+  equal(itemString.match(/EXDATE[A-Z;=-]*:20020403T114500Z/, null));
+  equal(itemString.match(/RDATE[A-Z;=-]*:20020401T114500Z/, null));
+  notEqual(itemString.match(/RRULE:[A-Z=,]*FREQ=DAILY/), null);
+  notEqual(itemString.match(/EXDATE[A-Z;=-]*:20020404T114500Z/, null));
+
+  // This may be an implementation detail, but we don't want this breaking
+  rinfo.wrappedJSObject.ensureSortedRecurrenceRules();
+  equal(
+    rinfo.wrappedJSObject.mNegativeRules[0].icalProperty.icalString,
+    newRItems[1].icalProperty.icalString
+  );
+  equal(
+    rinfo.wrappedJSObject.mPositiveRules[0].icalProperty.icalString,
+    newRItems[0].icalProperty.icalString
+  );
+
+  // countRecurrenceItems
+  equal(2, rinfo.countRecurrenceItems());
+
+  // clearRecurrenceItems
+  rinfo.clearRecurrenceItems();
+  equal(0, rinfo.countRecurrenceItems());
+
+  // appendRecurrenceItems / getRecurrenceItemAt / insertRecurrenceItemAt
+  rinfo.appendRecurrenceItem(ritems[0]);
+  rinfo.appendRecurrenceItem(ritems[1]);
+  rinfo.insertRecurrenceItemAt(ritems[2], 0);
+
+  ok(cal.data.compareObjects(ritems[2], rinfo.getRecurrenceItemAt(0), Ci.calIRecurrenceItem));
+  ok(cal.data.compareObjects(ritems[0], rinfo.getRecurrenceItemAt(1), Ci.calIRecurrenceItem));
+  ok(cal.data.compareObjects(ritems[1], rinfo.getRecurrenceItemAt(2), Ci.calIRecurrenceItem));
+
+  // deleteRecurrenceItem
+  rinfo.deleteRecurrenceItem(ritems[0]);
+  ok(!item.icalString.includes("RRULE"));
+
+  // deleteRecurrenceItemAt
+  rinfo.deleteRecurrenceItemAt(1);
+  itemString = item.icalString;
+  ok(!itemString.includes("EXDATE"));
+  ok(itemString.includes("RDATE"));
+
+  // insertRecurrenceItemAt with exdate
+  rinfo.insertRecurrenceItemAt(ritems[1], 1);
+  ok(cal.data.compareObjects(ritems[1], rinfo.getRecurrenceItemAt(1), Ci.calIRecurrenceItem));
+  rinfo.deleteRecurrenceItem(ritems[1]);
+
+  // isFinite = true
+  ok(rinfo.isFinite);
+  rinfo.appendRecurrenceItem(ritems[0]);
+  ok(rinfo.isFinite);
+
+  // isFinite = false
+  let item2 = makeEvent(
+    // eslint-disable-next-line no-useless-concat
+    "DTSTART:20020402T114500Z\n" + "DTEND:20020402T124500Z\n" + "RRULE:FREQ=WEEKLY;BYDAY=TU,WE\n"
+  );
+  ok(!item2.recurrenceInfo.isFinite);
+
+  // removeOccurrenceAt/restoreOccurreceAt
+  let occDate1 = cal.createDateTime("20020403T114500Z");
+  let occDate2 = cal.createDateTime("20020404T114500Z");
+  rinfo.removeOccurrenceAt(occDate1);
+  ok(item.icalString.includes("EXDATE"));
+  rinfo.restoreOccurrenceAt(occDate1);
+  ok(!item.icalString.includes("EXDATE"));
+
+  // modifyException / getExceptionFor
+  let occ1 = rinfo.getOccurrenceFor(occDate1);
+  occ1.QueryInterface(Ci.calIEvent);
+  occ1.startDate = cal.createDateTime("20020401T114500");
+  rinfo.modifyException(occ1, true);
+  ok(rinfo.getExceptionFor(occDate1) != null);
+
+  // modifyException immutable
+  let occ2 = rinfo.getOccurrenceFor(occDate2);
+  occ2.makeImmutable();
+  rinfo.modifyException(occ2, true);
+  ok(rinfo.getExceptionFor(occDate2) != null);
+
+  // getExceptionIds
+  let ids = rinfo.getExceptionIds();
+  equal(ids.length, 2);
+  ok(ids[0].compare(occDate1) == 0);
+  ok(ids[1].compare(occDate2) == 0);
+
+  // removeExceptionFor
+  rinfo.removeExceptionFor(occDate1);
+  ok(rinfo.getExceptionFor(occDate1) == null);
+  equal(rinfo.getExceptionIds().length, 1);
+}
+
+function test_rrule_interface() {
+  let item = makeEvent(
+    "DTSTART:20020402T114500Z\r\n" +
+      "DTEND:20020402T124500Z\r\n" +
+      "RRULE:INTERVAL=2;FREQ=WEEKLY;COUNT=6;BYDAY=TU,WE\r\n"
+  );
+
+  let rrule = item.recurrenceInfo.getRecurrenceItemAt(0);
+  rrule.QueryInterface(Ci.calIRecurrenceRule);
+  equal(rrule.type, "WEEKLY");
+  equal(rrule.interval, 2);
+  equal(rrule.count, 6);
+  ok(rrule.isByCount);
+  ok(!rrule.isNegative);
+  ok(rrule.isFinite);
+  equal(rrule.getComponent("BYDAY").toString(), [3, 4].toString());
+
+  // Now start changing things
+  rrule.setComponent("BYDAY", [4, 5]);
+  equal(rrule.icalString.match(/BYDAY=WE,TH/), "BYDAY=WE,TH");
+
+  rrule.count = -1;
+  ok(!rrule.isByCount);
+  ok(!rrule.isFinite);
+  equal(rrule.icalString.match(/COUNT=/), null);
+  throws(() => rrule.count, /0x80004005/);
+
+  rrule.interval = 1;
+  equal(rrule.interval, 1);
+  equal(rrule.icalString.match(/INTERVAL=/), null);
+
+  rrule.interval = 3;
+  equal(rrule.interval, 3);
+  equal(rrule.icalString.match(/INTERVAL=3/), "INTERVAL=3");
+
+  rrule.type = "MONTHLY";
+  equal(rrule.type, "MONTHLY");
+  equal(rrule.icalString.match(/FREQ=MONTHLY/), "FREQ=MONTHLY");
+
+  // untilDate (without UTC)
+  rrule.count = 3;
+  let untilDate = cal.createDateTime();
+  untilDate.timezone = cal.timezoneService.getTimezone("Europe/Berlin");
+  rrule.untilDate = untilDate;
+  ok(!rrule.isByCount);
+  throws(() => rrule.count, /0x80004005/);
+  equal(rrule.untilDate.icalString, untilDate.getInTimezone(cal.dtz.UTC).icalString);
+
+  // untilDate (with UTC)
+  rrule.count = 3;
+  untilDate = cal.createDateTime();
+  untilDate.timezone = cal.dtz.UTC;
+  rrule.untilDate = untilDate;
+  ok(!rrule.isByCount);
+  throws(() => rrule.count, /0x80004005/);
+  equal(rrule.untilDate.icalString, untilDate.icalString);
+}
+
+function test_startdate_change() {
+  // Setting a start date if its missing shouldn't throw
+  // eslint-disable-next-line no-useless-concat
+  let item = makeEvent("DTEND:20020402T124500Z\r\n" + "RRULE:FREQ=DAILY\r\n");
+  item.startDate = cal.createDateTime("20020502T114500Z");
+
+  function makeRecEvent(str) {
+    // eslint-disable-next-line no-useless-concat
+    return makeEvent("DTSTART:20020402T114500Z\r\n" + "DTEND:20020402T134500Z\r\n" + str);
+  }
+
+  function changeBy(changeItem, dur) {
+    let newDate = changeItem.startDate.clone();
+    newDate.addDuration(cal.createDuration(dur));
+    changeItem.startDate = newDate;
+  }
+
+  let ritem;
+
+  // Changing an existing start date for a recurring item shouldn't either
+  item = makeRecEvent("RRULE:FREQ=DAILY\r\n");
+  changeBy(item, "PT1H");
+
+  // Event with an rdate
+  item = makeRecEvent("RDATE:20020403T114500Z\r\n");
+  changeBy(item, "PT1H");
+  ritem = item.recurrenceInfo.getRecurrenceItemAt(0);
+  ritem.QueryInterface(Ci.calIRecurrenceDate);
+  equal(ritem.date.icalString, "20020403T124500Z");
+
+  // Event with an exdate
+  item = makeRecEvent("EXDATE:20020403T114500Z\r\n");
+  changeBy(item, "PT1H");
+  ritem = item.recurrenceInfo.getRecurrenceItemAt(0);
+  ritem.QueryInterface(Ci.calIRecurrenceDate);
+  equal(ritem.date.icalString, "20020403T124500Z");
+
+  // Event with an rrule with until date
+  item = makeRecEvent("RRULE:FREQ=WEEKLY;UNTIL=20020406T114500Z\r\n");
+  changeBy(item, "PT1H");
+  ritem = item.recurrenceInfo.getRecurrenceItemAt(0);
+  ritem.QueryInterface(Ci.calIRecurrenceRule);
+  equal(ritem.untilDate.icalString, "20020406T124500Z");
+
+  // Event with an exception item
+  item = makeRecEvent("RRULE:FREQ=DAILY\r\n");
+  let occ = item.recurrenceInfo.getOccurrenceFor(cal.createDateTime("20020406T114500Z"));
+  occ.QueryInterface(Ci.calIEvent);
+  occ.startDate = cal.createDateTime("20020406T124500Z");
+  item.recurrenceInfo.modifyException(occ, true);
+  changeBy(item, "PT1H");
+  equal(item.startDate.icalString, "20020402T124500Z");
+  occ = item.recurrenceInfo.getExceptionFor(cal.createDateTime("20020406T124500Z"));
+  occ.QueryInterface(Ci.calIEvent);
+  equal(occ.startDate.icalString, "20020406T134500Z");
+}
+
+function test_idchange() {
+  let item = makeEvent(
+    "UID:unchanged\r\n" +
+      "DTSTART:20020402T114500Z\r\n" +
+      "DTEND:20020402T124500Z\r\n" +
+      "RRULE:FREQ=DAILY\r\n"
+  );
+  let occ = item.recurrenceInfo.getOccurrenceFor(cal.createDateTime("20020406T114500Z"));
+  occ.QueryInterface(Ci.calIEvent);
+  occ.startDate = cal.createDateTime("20020406T124500Z");
+  item.recurrenceInfo.modifyException(occ, true);
+  equal(occ.id, "unchanged");
+
+  item.id = "changed";
+
+  occ = item.recurrenceInfo.getExceptionFor(cal.createDateTime("20020406T114500Z"));
+  equal(occ.id, "changed");
+}
+
+function test_failures() {
+  let item = makeEvent(
+    "DTSTART:20020402T114500Z\r\n" +
+      "DTEND:20020402T124500Z\r\n" +
+      "RRULE:INTERVAL=2;FREQ=WEEKLY;COUNT=6;BYDAY=TU,WE\r\n"
+  );
+  let rinfo = item.recurrenceInfo;
+  let ritem = cal.createRecurrenceDate();
+
+  throws(() => rinfo.getRecurrenceItemAt(-1), /Illegal value/, "Invalid Argument");
+  throws(() => rinfo.getRecurrenceItemAt(1), /Illegal value/, "Invalid Argument");
+  throws(() => rinfo.deleteRecurrenceItemAt(-1), /Illegal value/, "Invalid Argument");
+  throws(() => rinfo.deleteRecurrenceItemAt(1), /Illegal value/, "Invalid Argument");
+  throws(() => rinfo.deleteRecurrenceItem(ritem), /Illegal value/, "Invalid Argument");
+  throws(() => rinfo.insertRecurrenceItemAt(ritem, -1), /Illegal value/, "Invalid Argument");
+  throws(() => rinfo.insertRecurrenceItemAt(ritem, 2), /Illegal value/, "Invalid Argument");
+  throws(
+    () => rinfo.restoreOccurrenceAt(cal.createDateTime("20080101T010101")),
+    /Illegal value/,
+    "Invalid Argument"
+  );
+  throws(() => new CalRecurrenceInfo().isFinite, /Component not initialized/);
+
+  // modifyException with a different parent item
+  let occ = rinfo.getOccurrenceFor(cal.createDateTime("20120102T114500Z"));
+  occ.calendar = {};
+  occ.id = "1234";
+  occ.parentItem = occ;
+  throws(() => rinfo.modifyException(occ, true), /Illegal value/, "Invalid Argument");
+
+  occ = rinfo.getOccurrenceFor(cal.createDateTime("20120102T114500Z"));
+  occ.recurrenceId = null;
+  throws(() => rinfo.modifyException(occ, true), /Illegal value/, "Invalid Argument");
+
+  // Missing DTSTART/DUE but RRULE
+  item = createTodoFromIcalString(
+    "BEGIN:VCALENDAR\r\n" +
+      "BEGIN:VTODO\r\n" +
+      "RRULE:FREQ=DAILY\r\n" +
+      "END:VTODO\r\n" +
+      "END:VCALENDAR\r\n"
+  );
+  rinfo = item.recurrenceInfo;
+  equal(
+    rinfo.getOccurrenceDates(
+      cal.createDateTime("20120101T010101"),
+      cal.createDateTime("20120203T010101"),
+      0
+    ).length,
+    0
+  );
+}
+
+function test_immutable() {
+  let item = createTodoFromIcalString(
+    "BEGIN:VCALENDAR\r\n" +
+      "BEGIN:VTODO\r\n" +
+      "RRULE:FREQ=DAILY\r\n" +
+      "END:VTODO\r\n" +
+      "END:VCALENDAR\r\n"
+  );
+  ok(item.recurrenceInfo.isMutable);
+  let rinfo = item.recurrenceInfo.clone();
+  let ritem = cal.createRecurrenceDate();
+  rinfo.makeImmutable();
+  rinfo.makeImmutable(); // Doing so twice shouldn't throw
+  throws(() => rinfo.appendRecurrenceItem(ritem), /Can not modify immutable data container/);
+  ok(!rinfo.isMutable);
+
+  item.recurrenceInfo.appendRecurrenceItem(ritem);
+}
+
+function test_rrule_icalstring() {
+  let recRule = cal.createRecurrenceRule();
+  recRule.type = "DAILY";
+  recRule.interval = 4;
+  equal(recRule.icalString, "RRULE:FREQ=DAILY;INTERVAL=4\r\n");
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "DAILY";
+  recRule.setComponent("BYDAY", [2, 3, 4, 5, 6]);
+  equal(recRule.icalString, "RRULE:FREQ=DAILY;BYDAY=MO,TU,WE,TH,FR\r\n");
+  deepEqual(recRule.getComponent("BYDAY"), [2, 3, 4, 5, 6]);
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "WEEKLY";
+  recRule.interval = 3;
+  recRule.setComponent("BYDAY", [2, 4, 6]);
+  equal(recRule.icalString, "RRULE:FREQ=WEEKLY;INTERVAL=3;BYDAY=MO,WE,FR\r\n");
+  deepEqual(recRule.getComponent("BYDAY"), [2, 4, 6]);
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "MONTHLY";
+  recRule.setComponent("BYDAY", [2, 3, 4, 5, 6, 7, 1]);
+  equal(recRule.icalString, "RRULE:FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR,SA,SU\r\n");
+  deepEqual(recRule.getComponent("BYDAY"), [2, 3, 4, 5, 6, 7, 1]);
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "MONTHLY";
+  recRule.setComponent("BYDAY", [10]);
+  equal(recRule.icalString, "RRULE:FREQ=MONTHLY;BYDAY=1MO\r\n");
+  deepEqual(recRule.getComponent("BYDAY"), [10]);
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "MONTHLY";
+  recRule.setComponent("BYDAY", [20]);
+  equal(recRule.icalString, "RRULE:FREQ=MONTHLY;BYDAY=2WE\r\n");
+  deepEqual(recRule.getComponent("BYDAY"), [20]);
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "MONTHLY";
+  recRule.setComponent("BYDAY", [-22]);
+  equal(recRule.icalString, "RRULE:FREQ=MONTHLY;BYDAY=-2FR\r\n");
+  deepEqual(recRule.getComponent("BYDAY"), [-22]);
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "MONTHLY";
+  recRule.setComponent("BYMONTHDAY", [5]);
+  equal(recRule.icalString, "RRULE:FREQ=MONTHLY;BYMONTHDAY=5\r\n");
+  deepEqual(recRule.getComponent("BYMONTHDAY"), [5]);
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "MONTHLY";
+  recRule.setComponent("BYMONTHDAY", [1, 9, 17]);
+  equal(recRule.icalString, "RRULE:FREQ=MONTHLY;BYMONTHDAY=1,9,17\r\n");
+  deepEqual(recRule.getComponent("BYMONTHDAY"), [1, 9, 17]);
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "YEARLY";
+  recRule.setComponent("BYMONTH", [1]);
+  recRule.setComponent("BYMONTHDAY", [3]);
+  ok(
+    [
+      "RRULE:FREQ=YEARLY;BYMONTHDAY=3;BYMONTH=1\r\n",
+      "RRULE:FREQ=YEARLY;BYMONTH=1;BYMONTHDAY=3\r\n",
+    ].includes(recRule.icalString)
+  );
+  deepEqual(recRule.getComponent("BYMONTH"), [1]);
+  deepEqual(recRule.getComponent("BYMONTHDAY"), [3]);
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "YEARLY";
+  recRule.setComponent("BYMONTH", [4]);
+  recRule.setComponent("BYDAY", [3]);
+  ok(
+    [
+      "RRULE:FREQ=YEARLY;BYDAY=TU;BYMONTH=4\r\n",
+      "RRULE:FREQ=YEARLY;BYMONTH=4;BYDAY=TU\r\n",
+    ].includes(recRule.icalString)
+  );
+  deepEqual(recRule.getComponent("BYMONTH"), [4]);
+  deepEqual(recRule.getComponent("BYDAY"), [3]);
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "YEARLY";
+  recRule.setComponent("BYMONTH", [4]);
+  recRule.setComponent("BYDAY", [10]);
+  ok(
+    [
+      "RRULE:FREQ=YEARLY;BYDAY=1MO;BYMONTH=4\r\n",
+      "RRULE:FREQ=YEARLY;BYMONTH=4;BYDAY=1MO\r\n",
+    ].includes(recRule.icalString)
+  );
+  deepEqual(recRule.getComponent("BYMONTH"), [4]);
+  deepEqual(recRule.getComponent("BYDAY"), [10]);
+
+  recRule = cal.createRecurrenceRule();
+  recRule.type = "YEARLY";
+  recRule.setComponent("BYMONTH", [4]);
+  recRule.setComponent("BYDAY", [-22]);
+  ok(
+    [
+      "RRULE:FREQ=YEARLY;BYDAY=-2FR;BYMONTH=4\r\n",
+      "RRULE:FREQ=YEARLY;BYMONTH=4;BYDAY=-2FR\r\n",
+    ].includes(recRule.icalString)
+  );
+  deepEqual(recRule.getComponent("BYMONTH"), [4]);
+  deepEqual(recRule.getComponent("BYDAY"), [-22]);
+}
+
+function test_icalComponent() {
+  let duration = "PT3600S";
+  let eventString =
+    "DESCRIPTION:Repeat every Thursday starting Tue 2nd April 2002\n" +
+    "RRULE:FREQ=WEEKLY;INTERVAL=1;COUNT=6;BYDAY=TH\n" +
+    "DTSTART:20020402T114500\n" +
+    `DURATION:${duration}\n`;
+
+  let firstOccurrenceDate = createDate(2002, 4, 4, true, 11, 45, 0);
+
+  // Test each of these cases from the conditional in the icalComponent getter.
+  // * mIsProxy = true, value === null
+  // * mIsProxy = true, value !== null
+  // * mIsProxy = false, value === null
+  // * mIsProxy = false, value !== null
+  //
+  // Create a proxy for a given occurrence, modify properties on the proxy
+  // (checking before and after), then call the icalComponent getter to see
+  // whether both parent item and proxy item have the correct properties.
+
+  let parent = makeEvent(eventString);
+  let proxy = parent.recurrenceInfo.getOccurrenceFor(firstOccurrenceDate);
+
+  equal(parent.getProperty("DURATION"), duration);
+  equal(proxy.getProperty("DURATION"), duration);
+
+  equal(parent.getProperty("LOCATION"), null);
+  equal(proxy.getProperty("LOCATION"), null);
+
+  let newDuration = "PT2200S";
+  let location = "Sherwood Forest";
+
+  proxy.setProperty("DURATION", newDuration);
+  proxy.setProperty("LOCATION", location);
+
+  equal(parent.getProperty("DURATION"), duration);
+  equal(proxy.getProperty("DURATION"), newDuration);
+
+  equal(parent.getProperty("LOCATION"), null);
+  equal(proxy.getProperty("LOCATION"), location);
+
+  equal(parent.icalComponent.duration.toString(), duration);
+  equal(proxy.icalComponent.duration.toString(), newDuration);
+
+  equal(parent.icalComponent.location, null);
+  equal(proxy.icalComponent.location, location);
+
+  // Test for bug 580896.
+
+  let event = makeEvent(eventString);
+  equal(event.getProperty("DURATION"), duration, "event has correct DURATION");
+
+  let occurrence = event.recurrenceInfo.getOccurrenceFor(firstOccurrenceDate);
+
+  equal(occurrence.getProperty("DURATION"), duration, "occurrence has correct DURATION");
+  equal(Boolean(occurrence.getProperty("DTEND")), true, "occurrence has DTEND");
+
+  ok(occurrence.icalComponent.duration, "occurrence icalComponent has DURATION");
+
+  // Changing the end date causes the duration to be set to null.
+  occurrence.endDate = createDate(2002, 4, 3);
+
+  equal(occurrence.getProperty("DURATION"), null, "occurrence DURATION has been set to null");
+
+  ok(!occurrence.icalComponent.duration, "occurrence icalComponent does not have DURATION");
+}
diff --git a/comm/calendar/test/unit/test_recurrence_utils.js b/comm/calendar/test/unit/test_recurrence_utils.js
new file mode 100644
index 0000000000..53f1aaf99f
--- /dev/null
+++ b/comm/calendar/test/unit/test_recurrence_utils.js
@@ -0,0 +1,371 @@
+/* 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 { countOccurrences } = ChromeUtils.import(
+  "resource:///modules/calendar/calRecurrenceUtils.jsm"
+);
+
+function run_test() {
+  do_calendar_startup(run_next_test);
+}
+
+// tests for calRecurrenceUtils.jsm
+/* Incomplete - still missing test coverage for:
+ * recurrenceRule2String
+ * splitRecurrenceRules
+ * checkRecurrenceRule
+ */
+
+function getIcs(aProperties) {
+  let calendar = [
+    "BEGIN:VCALENDAR",
+    "PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN",
+    "VERSION:2.0",
+    "BEGIN:VTIMEZONE",
+    "TZID:Europe/Berlin",
+    "BEGIN:DAYLIGHT",
+    "TZOFFSETFROM:+0100",
+    "TZOFFSETTO:+0200",
+    "TZNAME:CEST",
+    "DTSTART:19700329T020000",
+    "RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=3",
+    "END:DAYLIGHT",
+    "BEGIN:STANDARD",
+    "TZOFFSETFROM:+0200",
+    "TZOFFSETTO:+0100",
+    "TZNAME:CET",
+    "DTSTART:19701025T030000",
+    "RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10",
+    "END:STANDARD",
+    "END:VTIMEZONE",
+  ];
+  calendar = calendar.concat(aProperties);
+  calendar = calendar.concat(["END:VCALENDAR"]);
+
+  return calendar.join("\r\n");
+}
+
+add_task(async function countOccurrences_test() {
+  let data = [
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98000",
+        "SUMMARY:Occurring 3 times until a date",
+        "RRULE:FREQ=DAILY;UNTIL=20180922T100000Z",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 3,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98001",
+        "SUMMARY:Occurring 3 times until a date with one exception in the middle",
+        "RRULE:FREQ=DAILY;UNTIL=20180922T100000Z",
+        "EXDATE;TZID=Europe/Berlin:20180921T120000",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 2,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98002",
+        "SUMMARY:Occurring 3 times until a date with one exception at the end",
+        "RRULE:FREQ=DAILY;UNTIL=20180922T100000Z",
+        "EXDATE;TZID=Europe/Berlin:20180922T120000",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 2,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98003",
+        "SUMMARY:Occurring 3 times until a date with one exception at the beginning",
+        "RRULE:FREQ=DAILY;UNTIL=20180922T100000Z",
+        "EXDATE;TZID=Europe/Berlin:20180920T120000",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 2,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98004",
+        "SUMMARY:Occurring 3 times until a date with the middle occurrence moved after the end",
+        "RRULE:FREQ=DAILY;UNTIL=20180922T100000Z",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98004",
+        "SUMMARY:The moved occurrence",
+        "RECURRENCE-ID:20180921T100000Z",
+        "DTSTART;TZID=Europe/Berlin:20180924T120000",
+        "DTEND;TZID=Europe/Berlin:20180924T130000",
+        "END:VEVENT",
+      ],
+      expected: 3,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98005",
+        "SUMMARY:Occurring 3 times until a date with the middle occurrence moved before the beginning",
+        "RRULE:FREQ=DAILY;UNTIL=20180922T100000Z",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98005",
+        "SUMMARY:The moved occurrence",
+        "RECURRENCE-ID:20180921T100000Z",
+        "DTSTART;TZID=Europe/Berlin:20180918T120000",
+        "DTEND;TZID=Europe/Berlin:20180918T130000",
+        "END:VEVENT",
+      ],
+      expected: 3,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98006",
+        "SUMMARY:Occurring 1 times until a date",
+        "RRULE:FREQ=DAILY;UNTIL=20180920T100000Z",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 1,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98007",
+        "SUMMARY:Occurring 1 times until a date with occernce removed",
+        "RRULE:FREQ=DAILY;UNTIL=20180920T100000Z",
+        "EXDATE;TZID=Europe/Berlin:20180920T120000",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 0,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98008",
+        "SUMMARY:Occurring for 3 times",
+        "RRULE:FREQ=DAILY;COUNT=3",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 3,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98009",
+        "SUMMARY:Occurring for 3 times with an exception in the middle",
+        "EXDATE;TZID=Europe/Berlin:20180921T120000",
+        "RRULE:FREQ=DAILY;COUNT=3",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 2,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98010",
+        "SUMMARY:Occurring for 3 times with an exception at the end",
+        "EXDATE;TZID=Europe/Berlin:20180922T120000",
+        "RRULE:FREQ=DAILY;COUNT=3",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 2,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98011",
+        "SUMMARY:Occurring for 3 times with an exception at the beginning",
+        "EXDATE;TZID=Europe/Berlin:20180920T120000",
+        "RRULE:FREQ=DAILY;COUNT=3",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 2,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98012",
+        "SUMMARY:Occurring for 1 time",
+        "RRULE:FREQ=DAILY;COUNT=1",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 1,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98013",
+        "SUMMARY:Occurring for 0 times",
+        "RRULE:FREQ=DAILY;COUNT=1",
+        "EXDATE;TZID=Europe/Berlin:20180920T120000",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 0,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98014",
+        "SUMMARY:Occurring infinitely",
+        "RRULE:FREQ=DAILY",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: null,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98015",
+        "SUMMARY:Non-occurring item",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: null,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98016",
+        "SUMMARY:Occurring for 3 time and 1 rdate",
+        "RRULE:FREQ=DAILY;COUNT=3",
+        "RDATE;TZID=Europe/Berlin:20180923T100000",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 4,
+    },
+    {
+      input: [
+        "BEGIN:VEVENT",
+        "CREATED:20180912T090539Z",
+        "LAST-MODIFIED:20180912T090539Z",
+        "DTSTAMP:20180912T090539Z",
+        "UID:5b47fa17-f2fe-4d96-8cc2-19ce5be98017",
+        "SUMMARY:Occurring for 3 rdates",
+        "RDATE;TZID=Europe/Berlin:20180920T120000",
+        "RDATE;TZID=Europe/Berlin:20180921T100000",
+        "RDATE;TZID=Europe/Berlin:20180922T140000",
+        "DTSTART;TZID=Europe/Berlin:20180920T120000",
+        "DTEND;TZID=Europe/Berlin:20180920T130000",
+        "END:VEVENT",
+      ],
+      expected: 3,
+    },
+  ];
+
+  let i = 0;
+  for (let test of data) {
+    i++;
+
+    let ics = getIcs(test.input);
+    let parser = Cc["@mozilla.org/calendar/ics-parser;1"].createInstance(Ci.calIIcsParser);
+    parser.parseString(ics);
+    let items = parser.getItems();
+
+    ok(items.length > 0, "parsing input succeeded (test #" + i + ")");
+    for (let item of items) {
+      equal(
+        countOccurrences(item),
+        test.expected,
+        "expected number of occurrences (test #" + i + " - '" + item.title + "')"
+      );
+    }
+  }
+});
diff --git a/comm/calendar/test/unit/test_relation.js b/comm/calendar/test/unit/test_relation.js
new file mode 100644
index 0000000000..148d5a6118
--- /dev/null
+++ b/comm/calendar/test/unit/test_relation.js
@@ -0,0 +1,133 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalRelation: "resource:///modules/CalRelation.jsm",
+});
+
+function run_test() {
+  // Create Relation
+  let relation1 = new CalRelation();
+
+  // Create Items
+  let event1 = new CalEvent();
+  let event2 = new CalEvent();
+
+  // Testing relation set/get.
+  let properties = {
+    relType: "PARENT",
+    relId: event2.id,
+  };
+
+  for (let [property, value] of Object.entries(properties)) {
+    relation1[property] = value;
+    equal(relation1[property], value);
+  }
+
+  // Add relation to event
+  event1.addRelation(relation1);
+
+  // Add 2nd relation to event.
+  let relation2 = new CalRelation();
+  relation2.relId = "myid2";
+  event1.addRelation(relation2);
+
+  // Check the item functions
+  checkRelations(event1, [relation1, relation2]);
+
+  // modify the Relations
+  modifyRelations(event1, [relation1, relation2]);
+
+  // test icalproperty
+  // eslint-disable-next-line no-unused-expressions
+  relation2.icalProperty;
+
+  test_icalprop();
+}
+
+function checkRelations(event, expRel) {
+  let allRel = event.getRelations();
+  equal(allRel.length, expRel.length);
+
+  // check if all expacted relations are found
+  for (let i = 0; i < expRel.length; i++) {
+    ok(allRel.includes(expRel[i]));
+  }
+
+  // Check if all found relations are expected
+  for (let i = 0; i < allRel.length; i++) {
+    ok(expRel.includes(allRel[i]));
+  }
+}
+
+function modifyRelations(event, oldRel) {
+  let allRel = event.getRelations();
+  let rel = allRel[0];
+
+  // modify the properties
+  rel.relType = "SIBLING";
+  equal(rel.relType, "SIBLING");
+  equal(rel.relType, allRel[0].relType);
+
+  // remove one relation
+  event.removeRelation(rel);
+  equal(event.getRelations().length, oldRel.length - 1);
+
+  // add one relation and remove all relations
+  event.addRelation(oldRel[0]);
+  event.removeAllRelations();
+  equal(event.getRelations(), 0);
+}
+
+function test_icalprop() {
+  let rel = new CalRelation();
+
+  rel.relType = "SIBLING";
+  rel.setParameter("X-PROP", "VAL");
+  rel.relId = "value";
+
+  let prop = rel.icalProperty;
+  let propOrig = rel.icalProperty;
+
+  equal(rel.icalString, prop.icalString);
+
+  equal(prop.value, "value");
+  equal(prop.getParameter("X-PROP"), "VAL");
+  equal(prop.getParameter("RELTYPE"), "SIBLING");
+
+  prop.value = "changed";
+  prop.setParameter("RELTYPE", "changedtype");
+  prop.setParameter("X-PROP", "changedxprop");
+
+  equal(rel.relId, "value");
+  equal(rel.getParameter("X-PROP"), "VAL");
+  equal(rel.relType, "SIBLING");
+
+  rel.icalProperty = prop;
+
+  equal(rel.relId, "changed");
+  equal(rel.getParameter("X-PROP"), "changedxprop");
+  equal(rel.relType, "changedtype");
+
+  rel.icalString = propOrig.icalString;
+
+  equal(rel.relId, "value");
+  equal(rel.getParameter("X-PROP"), "VAL");
+  equal(rel.relType, "SIBLING");
+
+  let rel2 = rel.clone();
+  rel.icalProperty = prop;
+
+  notEqual(rel.icalString, rel2.icalString);
+
+  rel.deleteParameter("X-PROP");
+  equal(rel.icalProperty.getParameter("X-PROP"), null);
+
+  throws(() => {
+    rel.icalString = "X-UNKNOWN:value";
+  }, /Illegal value/);
+}
diff --git a/comm/calendar/test/unit/test_rfc3339_parser.js b/comm/calendar/test/unit/test_rfc3339_parser.js
new file mode 100644
index 0000000000..8098bdddf6
--- /dev/null
+++ b/comm/calendar/test/unit/test_rfc3339_parser.js
@@ -0,0 +1,188 @@
+/* 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 run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  // Check if the RFC 3339 date and timezone are properly parsed to the
+  // expected result and if the result is properly mapped back into the RFC
+  // 3339 date.
+  function testRfc3339(
+    aRfc3339Date,
+    aTimezone,
+    aExpectedDateTime,
+    aExpectedRfc3339Date = aRfc3339Date
+  ) {
+    // Test creating a dateTime object from an RFC 3339 string.
+    let dateTime = cal.dtz.fromRFC3339(aRfc3339Date, aTimezone);
+
+    // Check that each property is as expected.
+    let expectedDateProps = {
+      year: aExpectedDateTime[0],
+      month: aExpectedDateTime[1] - 1, // 0 based month.
+      day: aExpectedDateTime[2],
+      hour: aExpectedDateTime[3],
+      minute: aExpectedDateTime[4],
+      second: aExpectedDateTime[5],
+      timezone: aExpectedDateTime[6],
+      isDate: aExpectedDateTime[7],
+    };
+    for (let prop in expectedDateProps) {
+      info("Checking prop: " + prop);
+      // Object comparison fails with ical.js, and we only want to check
+      // that we have the right timezone.
+      if (prop == "timezone") {
+        equal(dateTime[prop].tzid, expectedDateProps[prop].tzid);
+      } else {
+        equal(dateTime[prop], expectedDateProps[prop]);
+      }
+    }
+
+    // Test round tripping that dateTime object back to an RFC 3339 string.
+    let rfc3339Date = cal.dtz.toRFC3339(dateTime);
+
+    // In theory this should just match the input RFC 3339 date, but there are
+    // multiple ways of generating the same time, e.g. 2006-03-14Z is
+    // equivalent to 2006-03-14.
+    equal(rfc3339Date, aExpectedRfc3339Date);
+  }
+
+  /*
+   * Some notes about the differences between calIDateTime and the RFC 3339
+   * specification:
+   * 1. calIDateTime does not support fractions of a second, they are
+   *    stripped.
+   * 2. If a timezone cannot be matched to the given time offset, the
+   *    date/time is returned as a UTC date/time.
+   * 3. The first timezone (alphabetically) that has the same offset is
+   *    chosen.
+   * 4. Leap seconds are not supported by calIDateTime, it resets to
+   *    [0-23]:[0-59]:[0-59].
+   *
+   * All tests are done under the default timezone and UTC (although both
+   * should give the same time).
+   */
+
+  // An arbitrary timezone (that has daylight savings time).
+  let getTz = aTz => cal.timezoneService.getTimezone(aTz);
+  let timezone = getTz("America/New_York");
+  let utc = cal.dtz.UTC;
+
+  // Timezones used in tests. This isn't a great representation, as we don't
+  // care what the actual timezone is, just that the offset is correct. Offset
+  // isn't presently easily accessible from the timezone object, however.
+  let utcminus6 = getTz("America/Bahia_Banderas");
+  let dawson = getTz("America/Dawson");
+
+  /*
+   * Basic tests
+   */
+  // This represents March 14, 2006 in the default timezone.
+  testRfc3339("2006-03-14", timezone, [2006, 3, 14, 0, 0, 0, timezone, true]);
+  testRfc3339("2006-03-14", utc, [2006, 3, 14, 0, 0, 0, utc, true]);
+  // This represents March 14, 2006 in UTC.
+  testRfc3339("2006-03-14Z", timezone, [2006, 3, 14, 0, 0, 0, utc, true], "2006-03-14");
+  testRfc3339("2006-03-14Z", utc, [2006, 3, 14, 0, 0, 0, utc, true], "2006-03-14");
+
+  // This represents 30 minutes and 53 seconds past the 13th hour of November
+  // 14, 2050 in UTC.
+  testRfc3339(
+    "2050-11-14t13:30:53z",
+    timezone,
+    [2050, 11, 14, 13, 30, 53, utc, false],
+    "2050-11-14T13:30:53Z"
+  );
+  testRfc3339(
+    "2050-11-14t13:30:53z",
+    utc,
+    [2050, 11, 14, 13, 30, 53, utc, false],
+    "2050-11-14T13:30:53Z"
+  );
+
+  // This represents 03:00:23 on October 14, 2004 in Central Standard Time.
+  testRfc3339("2004-10-14T03:00:23-06:00", timezone, [2004, 10, 14, 3, 0, 23, utcminus6, false]);
+  testRfc3339("2004-10-14T03:00:23-06:00", utc, [2004, 10, 14, 3, 0, 23, utcminus6, false]);
+
+  /*
+   * The following tests are the RFC 3339 examples
+   * http://tools.ietf.org/html/rfc3339
+   * Most of these would "fail" since iCalDateTime does not supported
+   * all parts of the specification, the true proper response is next to each
+   * test line as a comment.
+   */
+
+  // This represents 20 minutes and 50.52 seconds after the 23rd hour of
+  // April 12th, 1985 in UTC.
+  testRfc3339(
+    "1985-04-12T23:20:50.52Z",
+    timezone,
+    [1985, 4, 12, 23, 20, 50, utc, false],
+    "1985-04-12T23:20:50Z"
+  ); // 1985/04/12 23:20:50.52 UTC isDate=0
+  testRfc3339(
+    "1985-04-12T23:20:50.52Z",
+    utc,
+    [1985, 4, 12, 23, 20, 50, utc, false],
+    "1985-04-12T23:20:50Z"
+  ); // 1985/04/12 23:20:50.52 UTC isDate=0
+
+  // This represents 39 minutes and 57 seconds after the 16th hour of December
+  // 19th, 1996 with an offset of -08:00 from UTC (Pacific Standard Time).
+  // Note that this is equivalent to in UTC.
+  testRfc3339("1996-12-19T16:39:57-08:00", timezone, [1996, 12, 19, 16, 39, 57, dawson, false]);
+  testRfc3339("1996-12-19T16:39:57-08:00", utc, [1996, 12, 19, 16, 39, 57, dawson, false]);
+  testRfc3339("1996-12-20T00:39:57Z", timezone, [1996, 12, 20, 0, 39, 57, utc, false]);
+  testRfc3339("1996-12-20T00:39:57Z", utc, [1996, 12, 20, 0, 39, 57, utc, false]);
+
+  // This represents the same instant of time as noon, January 1, 1937,
+  // Netherlands time. Standard time in the Netherlands was exactly 19 minutes
+  // and 32.13 seconds ahead of UTC by law from 1909-05-01 through 1937-06-30.
+  // This time zone cannot be represented exactly using the HH:MM format, and
+  // this timestamp uses the closest representable UTC offset.
+  //
+  // Since no current timezone exists at +00:20 it will default to giving the
+  // time in UTC.
+  testRfc3339(
+    "1937-01-01T12:00:27.87+00:20",
+    timezone,
+    [1937, 1, 1, 12, 20, 27, utc, false],
+    "1937-01-01T12:20:27Z"
+  ); // 1937/01/01 12:20:27.87 UTC isDate=0
+  testRfc3339(
+    "1937-01-01T12:00:27.87+00:20",
+    utc,
+    [1937, 1, 1, 12, 20, 27, utc, false],
+    "1937-01-01T12:20:27Z"
+  ); // 1937/01/01 12:20:27.87 UTC isDate=0
+
+  // This represents the leap second inserted at the end of 1990.
+  testRfc3339(
+    "1990-12-31T23:59:60Z",
+    timezone,
+    [1991, 1, 1, 0, 0, 0, utc, false],
+    "1991-01-01T00:00:00Z"
+  ); // 1990/12/31 23:59:60 UTC isDate=0
+  testRfc3339(
+    "1990-12-31T23:59:60Z",
+    utc,
+    [1991, 1, 1, 0, 0, 0, utc, false],
+    "1991-01-01T00:00:00Z"
+  ); // 1990/12/31 23:59:60 UTC isDate=0
+  // This represents the same leap second in Pacific Standard Time, 8
+  // hours behind UTC.
+  testRfc3339(
+    "1990-12-31T15:59:60-08:00",
+    timezone,
+    [1990, 12, 31, 16, 0, 0, dawson, false],
+    "1990-12-31T16:00:00-08:00"
+  ); // 1990/12/31 15:59:60 America/Dawson isDate=0
+  testRfc3339(
+    "1990-12-31T15:59:60-08:00",
+    utc,
+    [1990, 12, 31, 16, 0, 0, dawson, false],
+    "1990-12-31T16:00:00-08:00"
+  ); // 1990/12/31 15:59:60 America/Dawson isDate=0
+}
diff --git a/comm/calendar/test/unit/test_startup_service.js b/comm/calendar/test/unit/test_startup_service.js
new file mode 100644
index 0000000000..cfb3f76571
--- /dev/null
+++ b/comm/calendar/test/unit/test_startup_service.js
@@ -0,0 +1,46 @@
+/* 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 run_test() {
+  let ssvc = Cc["@mozilla.org/calendar/startup-service;1"].getService(Ci.nsIObserver);
+
+  let first = {
+    startup(aListener) {
+      second.canStart = true;
+      aListener.onResult(null, Cr.NS_OK);
+    },
+    shutdown(aListener) {
+      ok(this.canStop);
+      aListener.onResult(null, Cr.NS_OK);
+    },
+  };
+
+  let second = {
+    startup(aListener) {
+      ok(this.canStart);
+      aListener.onResult(null, Cr.NS_OK);
+    },
+    shutdown(aListener) {
+      first.canStop = true;
+      aListener.onResult(null, Cr.NS_OK);
+    },
+  };
+
+  // Change the startup order so we can test our services
+  let oldStartupOrder = ssvc.wrappedJSObject.getStartupOrder;
+  ssvc.wrappedJSObject.getStartupOrder = function () {
+    let origOrder = oldStartupOrder.call(this);
+
+    let notify = origOrder[origOrder.length - 1];
+    return [first, second, notify];
+  };
+
+  // Pretend a startup run
+  ssvc.observe(null, "profile-after-change", null);
+  ok(second.canStart);
+
+  // Pretend a stop run
+  ssvc.observe(null, "profile-before-change", null);
+  ok(first.canStop);
+}
diff --git a/comm/calendar/test/unit/test_storage.js b/comm/calendar/test/unit/test_storage.js
new file mode 100644
index 0000000000..d4a42be428
--- /dev/null
+++ b/comm/calendar/test/unit/test_storage.js
@@ -0,0 +1,85 @@
+/* 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 new Promise(resolve => {
+    do_calendar_startup(resolve);
+  });
+
+  let storage = getStorageCal();
+  let str = [
+    "BEGIN:VEVENT",
+    "UID:attachItem",
+    "DTSTART:20120101T010101Z",
+    "ATTACH;FMTTYPE=text/calendar;ENCODING=BASE64;FILENAME=test.ics:http://example.com/test.ics",
+    "ATTENDEE;RSVP=TRUE;CUTYPE=INDIVIDUAL;CN=Name;PARTSTAT=ACCEPTED;ROLE=REQ-PARTICIPANT;X-THING=BAR:mailto:test@example.com",
+    "RELATED-TO;RELTYPE=SIBLING;FOO=BAR:VALUE",
+    "RRULE:FREQ=MONTHLY;INTERVAL=2;COUNT=5;BYDAY=MO",
+    "RDATE:20120201T010101Z",
+    "EXDATE:20120301T010101Z",
+    "END:VEVENT",
+  ].join("\r\n");
+
+  let storageItem = createEventFromIcalString(str);
+
+  let addedItemId = (await storage.addItem(storageItem)).id;
+
+  // Make sure the cache is cleared, otherwise we'll get the cached item.
+  delete storage.wrappedJSObject.mItemModel.itemCache[addedItemId];
+
+  let item = await storage.getItem(addedItemId);
+
+  // Check start date
+  equal(item.startDate.compare(cal.createDateTime("20120101T010101Z")), 0);
+
+  // Check attachment
+  let attaches = item.getAttachments();
+  let attach = attaches[0];
+  equal(attaches.length, 1);
+  equal(attach.uri.spec, "http://example.com/test.ics");
+  equal(attach.formatType, "text/calendar");
+  equal(attach.encoding, "BASE64");
+  equal(attach.getParameter("FILENAME"), "test.ics");
+
+  // Check attendee
+  let attendees = item.getAttendees();
+  let attendee = attendees[0];
+  equal(attendees.length, 1);
+  equal(attendee.id, "mailto:test@example.com");
+  equal(attendee.commonName, "Name");
+  equal(attendee.rsvp, "TRUE");
+  equal(attendee.isOrganizer, false);
+  equal(attendee.role, "REQ-PARTICIPANT");
+  equal(attendee.participationStatus, "ACCEPTED");
+  equal(attendee.userType, "INDIVIDUAL");
+  equal(attendee.getProperty("X-THING"), "BAR");
+
+  // Check relation
+  let relations = item.getRelations();
+  let rel = relations[0];
+  equal(relations.length, 1);
+  equal(rel.relType, "SIBLING");
+  equal(rel.relId, "VALUE");
+  equal(rel.getParameter("FOO"), "BAR");
+
+  // Check recurrence item
+  for (let ritem of item.recurrenceInfo.getRecurrenceItems()) {
+    if (ritem instanceof Ci.calIRecurrenceRule) {
+      equal(ritem.type, "MONTHLY");
+      equal(ritem.interval, 2);
+      equal(ritem.count, 5);
+      equal(ritem.isByCount, true);
+      equal(ritem.getComponent("BYDAY").toString(), [2].toString());
+      equal(ritem.isNegative, false);
+    } else if (ritem instanceof Ci.calIRecurrenceDate) {
+      if (ritem.isNegative) {
+        equal(ritem.date.compare(cal.createDateTime("20120301T010101Z")), 0);
+      } else {
+        equal(ritem.date.compare(cal.createDateTime("20120201T010101Z")), 0);
+      }
+    } else {
+      do_throw("Found unknown recurrence item " + ritem);
+    }
+  }
+});
diff --git a/comm/calendar/test/unit/test_storage_connection.js b/comm/calendar/test/unit/test_storage_connection.js
new file mode 100644
index 0000000000..2984fa2dc4
--- /dev/null
+++ b/comm/calendar/test/unit/test_storage_connection.js
@@ -0,0 +1,127 @@
+/* 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_setup(async function () {
+  do_get_profile();
+  await new Promise(resolve => cal.manager.startup({ onResult: resolve }));
+});
+
+/**
+ * Tests that local storage calendars share a database connection.
+ */
+add_task(async function testLocal() {
+  let localCalendarA = cal.manager.createCalendar(
+    "storage",
+    Services.io.newURI(`moz-storage-calendar://`)
+  );
+  localCalendarA.id = cal.getUUID();
+  let dbA = localCalendarA.wrappedJSObject.mStorageDb.db;
+
+  let localCalendarB = cal.manager.createCalendar(
+    "storage",
+    Services.io.newURI(`moz-storage-calendar://`)
+  );
+  localCalendarB.id = cal.getUUID();
+  let dbB = localCalendarB.wrappedJSObject.mStorageDb.db;
+
+  Assert.equal(
+    dbA.databaseFile.path,
+    PathUtils.join(PathUtils.profileDir, "calendar-data", "local.sqlite"),
+    "local calendar A uses the right database file"
+  );
+  Assert.equal(
+    dbB.databaseFile.path,
+    PathUtils.join(PathUtils.profileDir, "calendar-data", "local.sqlite"),
+    "local calendar B uses the right database file"
+  );
+  Assert.equal(dbA, dbB, "local calendars share a database connection");
+});
+
+/**
+ * Tests that local storage calendars using the same specified database file share a connection,
+ * and that local storage calendars with a different specified database file do not.
+ */
+add_task(async function testLocalFile() {
+  let testFileA = new FileUtils.File(PathUtils.join(PathUtils.tempDir, "file-a.sqlite"));
+  let testFileB = new FileUtils.File(PathUtils.join(PathUtils.tempDir, "file-b.sqlite"));
+
+  let fileCalendarA = cal.manager.createCalendar("storage", Services.io.newFileURI(testFileA));
+  fileCalendarA.id = cal.getUUID();
+  let dbA = fileCalendarA.wrappedJSObject.mStorageDb.db;
+
+  let fileCalendarB = cal.manager.createCalendar("storage", Services.io.newFileURI(testFileB));
+  fileCalendarB.id = cal.getUUID();
+  let dbB = fileCalendarB.wrappedJSObject.mStorageDb.db;
+
+  let fileCalendarC = cal.manager.createCalendar("storage", Services.io.newFileURI(testFileA));
+  fileCalendarC.id = cal.getUUID();
+  let dbC = fileCalendarC.wrappedJSObject.mStorageDb.db;
+
+  Assert.equal(
+    dbA.databaseFile.path,
+    testFileA.path,
+    "local calendar A uses the right database file"
+  );
+  Assert.equal(
+    dbB.databaseFile.path,
+    testFileB.path,
+    "local calendar B uses the right database file"
+  );
+  Assert.equal(
+    dbC.databaseFile.path,
+    testFileA.path,
+    "local calendar C uses the right database file"
+  );
+  Assert.notEqual(
+    dbA,
+    dbB,
+    "calendars with different file URLs do not share a database connection"
+  );
+  Assert.notEqual(
+    dbB,
+    dbC,
+    "calendars with different file URLs do not share a database connection"
+  );
+  Assert.equal(dbA, dbC, "calendars with matching file URLs share a database connection");
+});
+
+/**
+ * Tests that cached network calendars share a database connection.
+ */
+add_task(async function testNetwork() {
+  // Pretend to be offline so connecting to calendars that don't exist doesn't throw errors.
+  Services.io.offline = true;
+
+  let networkCalendarA = cal.manager.createCalendar(
+    "ics",
+    Services.io.newURI("http://localhost/ics")
+  );
+  networkCalendarA.id = cal.getUUID();
+  networkCalendarA.setProperty("cache.enabled", true);
+  cal.manager.registerCalendar(networkCalendarA);
+  networkCalendarA = cal.manager.getCalendarById(networkCalendarA.id);
+  let dbA = networkCalendarA.wrappedJSObject.mCachedCalendar.wrappedJSObject.mStorageDb.db;
+
+  let networkCalendarB = cal.manager.createCalendar(
+    "caldav",
+    Services.io.newURI("http://localhost/caldav")
+  );
+  networkCalendarB.id = cal.getUUID();
+  networkCalendarB.setProperty("cache.enabled", true);
+  cal.manager.registerCalendar(networkCalendarB);
+  networkCalendarB = cal.manager.getCalendarById(networkCalendarB.id);
+  let dbB = networkCalendarB.wrappedJSObject.mCachedCalendar.wrappedJSObject.mStorageDb.db;
+
+  Assert.equal(
+    dbA.databaseFile.path,
+    PathUtils.join(PathUtils.profileDir, "calendar-data", "cache.sqlite"),
+    "network calendar A uses the right database file"
+  );
+  Assert.equal(
+    dbB.databaseFile.path,
+    PathUtils.join(PathUtils.profileDir, "calendar-data", "cache.sqlite"),
+    "network calendar B uses the right database file"
+  );
+  Assert.equal(dbA, dbB, "network calendars share a database connection");
+});
diff --git a/comm/calendar/test/unit/test_storage_get_items.js b/comm/calendar/test/unit/test_storage_get_items.js
new file mode 100644
index 0000000000..828e59fecd
--- /dev/null
+++ b/comm/calendar/test/unit/test_storage_get_items.js
@@ -0,0 +1,338 @@
+/* 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/. */
+
+/**
+ * Tests for the CalStorageCalendar.getItems method.
+ */
+
+const { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+const { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+const { CalTodo } = ChromeUtils.import("resource:///modules/CalTodo.jsm");
+
+do_get_profile();
+
+/**
+ * The bug we are interested in testing requires the calendar to clear its
+ * caches in order to take effect. Since we can't directly access the internals
+ * of the calendar here, we instead provide a custom function that lets us
+ * create more than one calendar with the same id.
+ */
+function createStorageCalendar(id) {
+  let db = Services.dirsvc.get("TmpD", Ci.nsIFile);
+  db.append("test_storage.sqlite");
+  let uri = Services.io.newFileURI(db);
+
+  // Make sure timezone service is initialized
+  Cc["@mozilla.org/calendar/timezone-service;1"].getService(Ci.calIStartupService).startup(null);
+
+  let calendar = Cc["@mozilla.org/calendar/calendar;1?type=storage"].createInstance(
+    Ci.calISyncWriteCalendar
+  );
+
+  calendar.uri = uri;
+  calendar.id = id;
+  return calendar;
+}
+
+/**
+ * Tests that recurring event/todo exceptions have their properties properly
+ * loaded. See bug 1664731.
+ *
+ * @param {number} filterType - Number indicating the filter type.
+ * @param {calIITemBase} originalItem - The original item to add to the calendar.
+ * @param {object} originalProps - The initial properites of originalItem to
+ *  expect.
+ * @param {object[]} changedProps - A list containing property values to update
+ *  each occurrence with or null. The length indicates how many occurrences to
+ *  expect.
+ */
+async function doPropertiesTest(filterType, originalItem, originalProps, changedPropList) {
+  for (let [key, value] of Object.entries(originalProps)) {
+    if (key == "CATEGORIES") {
+      originalItem.setCategories(value);
+    } else {
+      originalItem.setProperty(key, value);
+    }
+  }
+
+  let calId = cal.getUUID();
+  let calendar = createStorageCalendar(calId);
+  await calendar.addItem(originalItem);
+
+  let filter =
+    filterType |
+    Ci.calICalendar.ITEM_FILTER_COMPLETED_ALL |
+    Ci.calICalendar.ITEM_FILTER_CLASS_OCCURRENCES;
+
+  let savedItems = await calendar.getItemsAsArray(
+    filter,
+    0,
+    cal.createDateTime("20201201T000000Z"),
+    cal.createDateTime("20201231T000000Z")
+  );
+
+  Assert.equal(
+    savedItems.length,
+    changedPropList.length,
+    `created ${changedPropList.length} items successfully`
+  );
+
+  // Ensure all occurrences have the correct properties initially.
+  for (let item of savedItems) {
+    for (let [key, value] of Object.entries(originalProps)) {
+      if (key == "CATEGORIES") {
+        Assert.equal(
+          item.getCategories().join(),
+          value.join(),
+          `item categories are set to ${value}`
+        );
+      } else {
+        Assert.equal(item.getProperty(key), value, `item property "${key}" is set to "${value}"`);
+      }
+    }
+  }
+
+  // Modify the occurrences that have new properties set in changedPropList.
+  for (let idx = 0; idx < changedPropList.length; idx++) {
+    let changedProps = changedPropList[idx];
+    if (changedProps) {
+      let targetOccurrence = savedItems[idx];
+      let targetException = targetOccurrence.clone();
+
+      // Make the changes to the properties.
+      for (let [key, value] of Object.entries(changedProps)) {
+        if (key == "CATEGORIES") {
+          targetException.setCategories(value);
+        } else {
+          targetException.setProperty(key, value);
+        }
+      }
+
+      await calendar.modifyItem(
+        cal.itip.prepareSequence(targetException, targetOccurrence),
+        targetOccurrence
+      );
+
+      // Refresh the saved items list after the change.
+      savedItems = await calendar.getItemsAsArray(
+        filter,
+        0,
+        cal.createDateTime("20201201T000000Z"),
+        cal.createDateTime("20201231T000000Z")
+      );
+    }
+  }
+
+  // Get a fresh copy of the occurrences by using a new calendar with the
+  // same id.
+  let itemsAfterUpdate = await createStorageCalendar(calId).getItemsAsArray(
+    filter,
+    0,
+    cal.createDateTime("20201201T000000Z"),
+    cal.createDateTime("20201231T000000Z")
+  );
+
+  Assert.equal(
+    itemsAfterUpdate.length,
+    changedPropList.length,
+    `count of occurrences retrieved after update is ${changedPropList.length}`
+  );
+
+  // Compare each property of each occurrence to ensure the changed
+  // occurrences have the values we expect.
+  for (let i = 0; i < itemsAfterUpdate.length; i++) {
+    let item = itemsAfterUpdate[i];
+    let isException = changedPropList[i] != null;
+    let label = isException ? `modified occurrence ${i}` : `unmodified occurrence ${i}`;
+    let checkedProps = isException ? changedPropList[i] : originalProps;
+
+    for (let [key, value] of Object.entries(checkedProps)) {
+      if (key == "CATEGORIES") {
+        Assert.equal(
+          item.getCategories().join(),
+          value.join(),
+          `item categories has value "${value}"`
+        );
+      } else {
+        Assert.equal(
+          item.getProperty(key),
+          value,
+          `property "${key}" has value "${value}" for "${label}"`
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Test event exceptions load their properties.
+ */
+add_task(async function testEventPropertiesForRecurringExceptionsLoad() {
+  let event = new CalEvent(CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      CREATED:20201211T000000Z
+      LAST-MODIFIED:20201211T000000Z
+      DTSTAMP:20201210T080410Z
+      UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5
+      SUMMARY:Original Test Event
+      DTSTART:20201211T000000Z
+      DTEND:20201211T110000Z
+      RRULE:FREQ=DAILY;UNTIL=20201215T140000Z
+      END:VEVENT
+    `);
+
+  let originalProps = {
+    DESCRIPTION: "This is a test event.",
+    CATEGORIES: ["Birthday"],
+    LOCATION: "Castara",
+  };
+
+  let changedProps = [
+    null,
+    null,
+    {
+      DESCRIPTION: "This is an edited occurrence.",
+      CATEGORIES: ["Holiday"],
+      LOCATION: "Georgetown",
+    },
+    null,
+    null,
+  ];
+
+  return doPropertiesTest(
+    Ci.calICalendar.ITEM_FILTER_TYPE_EVENT,
+    event,
+    originalProps,
+    changedProps
+  );
+});
+
+/**
+ * Test todo exceptions load their properties.
+ */
+add_task(async function testTodoPropertiesForRecurringExceptionsLoad() {
+  let todo = new CalTodo(CalendarTestUtils.dedent`
+      BEGIN:VTODO
+      CREATED:20201211T000000Z
+      LAST-MODIFIED:20201211T000000Z
+      DTSTAMP:20201210T080410Z
+      UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5
+      SUMMARY:Original Test Event
+      DTSTART:20201211T000000Z
+      DTEND:20201211T110000Z
+      RRULE:FREQ=DAILY;UNTIL=20201215T140000Z
+      END:VTODO
+    `);
+
+  let originalProps = {
+    DESCRIPTION: "This is a test todo.",
+    CATEGORIES: ["Birthday"],
+    LOCATION: "Castara",
+    STATUS: "NEEDS-ACTION",
+  };
+
+  let changedProps = [
+    null,
+    null,
+    {
+      DESCRIPTION: "This is an edited occurrence.",
+      CATEGORIES: ["Holiday"],
+      LOCATION: "Georgetown",
+      STATUS: "COMPLETE",
+    },
+    null,
+    null,
+  ];
+
+  return doPropertiesTest(Ci.calICalendar.ITEM_FILTER_TYPE_TODO, todo, originalProps, changedProps);
+});
+
+/**
+ * Tests calling getItems() does not overwrite subsequent event occurrence
+ * exceptions with their parent item. See bug 1686466.
+ */
+add_task(async function testRecurringEventChangesAreNotHiddenByCache() {
+  let event = new CalEvent(CalendarTestUtils.dedent`
+      BEGIN:VEVENT
+      CREATED:20201211T000000Z
+      LAST-MODIFIED:20201211T000000Z
+      DTSTAMP:20201210T080410Z
+      UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5
+      SUMMARY:Original Test Event
+      DTSTART:20201211T000000Z
+      DTEND:20201211T110000Z
+      RRULE:FREQ=DAILY;UNTIL=20201215T140000Z
+      END:VEVENT
+    `);
+
+  let originalProps = {
+    LOCATION: "San Juan",
+  };
+
+  let changedProps = [
+    null,
+    {
+      LOCATION: "Buenos Aries",
+    },
+    {
+      LOCATION: "Bridgetown",
+    },
+    {
+      LOCATION: "Freetown",
+    },
+    null,
+  ];
+
+  return doPropertiesTest(
+    Ci.calICalendar.ITEM_FILTER_TYPE_EVENT,
+    event,
+    originalProps,
+    changedProps,
+    true
+  );
+});
+
+/**
+ * Tests calling getItems() does not overwrite subsequent todo occurrence
+ * exceptions with their parent item. See bug 1686466.
+ */
+add_task(async function testRecurringTodoChangesNotHiddenByCache() {
+  let todo = new CalTodo(CalendarTestUtils.dedent`
+      BEGIN:VTODO
+      CREATED:20201211T000000Z
+      LAST-MODIFIED:20201211T000000Z
+      DTSTAMP:20201210T080410Z
+      UID:c1a6cfe7-7fbb-4bfb-a00d-861e07c649a5
+      SUMMARY:Original Test Event
+      DTSTART:20201211T000000Z
+      DTEND:20201211T110000Z
+      RRULE:FREQ=DAILY;UNTIL=20201215T140000Z
+      END:VTODO
+    `);
+
+  let originalProps = {
+    DESCRIPTION: "This is a test todo.",
+    CATEGORIES: ["Birthday"],
+    LOCATION: "Castara",
+    STATUS: "NEEDS-ACTION",
+  };
+
+  let changedProps = [
+    null,
+    {
+      STATUS: "COMPLETE",
+    },
+    {
+      STATUS: "COMPLETE",
+    },
+    {
+      STATUS: "COMPLETE",
+    },
+    null,
+  ];
+
+  return doPropertiesTest(Ci.calICalendar.ITEM_FILTER_TYPE_TODO, todo, originalProps, changedProps);
+});
diff --git a/comm/calendar/test/unit/test_timezone.js b/comm/calendar/test/unit/test_timezone.js
new file mode 100644
index 0000000000..d11b380b52
--- /dev/null
+++ b/comm/calendar/test/unit/test_timezone.js
@@ -0,0 +1,89 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+});
+
+function run_test() {
+  do_test_pending();
+  cal.timezoneService.QueryInterface(Ci.calIStartupService).startup({
+    onResult() {
+      really_run_test();
+      do_test_finished();
+    },
+  });
+}
+
+function really_run_test() {
+  let event = new CalEvent();
+
+  let str = [
+    "BEGIN:VCALENDAR",
+    "PRODID:-//RDU Software//NONSGML HandCal//EN",
+    "VERSION:2.0",
+    "BEGIN:VTIMEZONE",
+    "TZID:America/New_York",
+    "BEGIN:STANDARD",
+    "DTSTART:19981025T020000",
+    "TZOFFSETFROM:-0400",
+    "TZOFFSETTO:-0500",
+    "TZNAME:EST",
+    "END:STANDARD",
+    "BEGIN:DAYLIGHT",
+    "DTSTART:19990404T020000",
+    "TZOFFSETFROM:-0500",
+    "TZOFFSETTO:-0400",
+    "TZNAME:EDT",
+    "END:DAYLIGHT",
+    "END:VTIMEZONE",
+    "BEGIN:VEVENT",
+    "DTSTAMP:19980309T231000Z",
+    "UID:guid-1.example.com",
+    "ORGANIZER:mailto:mrbig@example.com",
+    "ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:",
+    " mailto:employee-A@example.com",
+    "DESCRIPTION:Project XYZ Review Meeting",
+    "CATEGORIES:MEETING",
+    "CLASS:PUBLIC",
+    "CREATED:19980309T130000Z",
+    "SUMMARY:XYZ Project Review",
+    "DTSTART;TZID=America/New_York:19980312T083000",
+    "DTEND;TZID=America/New_York:19980312T093000",
+    "LOCATION:1CP Conference Room 4350",
+    "END:VEVENT",
+    "END:VCALENDAR",
+    "",
+  ].join("\r\n");
+
+  let strTz = [
+    "BEGIN:VTIMEZONE",
+    "TZID:America/New_York",
+    "BEGIN:STANDARD",
+    "DTSTART:19981025T020000",
+    "TZOFFSETFROM:-0400",
+    "TZOFFSETTO:-0500",
+    "TZNAME:EST",
+    "END:STANDARD",
+    "BEGIN:DAYLIGHT",
+    "DTSTART:19990404T020000",
+    "TZOFFSETFROM:-0500",
+    "TZOFFSETTO:-0400",
+    "TZNAME:EDT",
+    "END:DAYLIGHT",
+    "END:VTIMEZONE",
+    "",
+  ].join("\r\n");
+
+  event.icalString = str;
+
+  let startDate = event.startDate;
+  let endDate = event.endDate;
+
+  startDate.timezone = cal.timezoneService.getTimezone(startDate.timezone.tzid);
+  endDate.timezone = cal.timezoneService.getTimezone(endDate.timezone.tzid);
+  notEqual(strTz, startDate.timezone.toString());
+}
diff --git a/comm/calendar/test/unit/test_timezone_changes.js b/comm/calendar/test/unit/test_timezone_changes.js
new file mode 100644
index 0000000000..125187ca67
--- /dev/null
+++ b/comm/calendar/test/unit/test_timezone_changes.js
@@ -0,0 +1,93 @@
+/* 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 FEBRUARY = 1;
+const OCTOBER = 9;
+const NOVEMBER = 10;
+
+const UTC_MINUS_3 = -3 * 3600;
+const UTC_MINUS_2 = -2 * 3600;
+
+function run_test() {
+  do_calendar_startup(run_next_test);
+}
+
+// This test requires timezone data going back to 2016. It's been kept here as an example.
+/* add_test(function testCaracas() {
+    let time = cal.createDateTime();
+    let zone = cal.timezoneService.getTimezone("America/Caracas");
+
+    for (let month = JANUARY; month <= DECEMBER; month++) {
+        time.resetTo(2015, month, 1, 0, 0, 0, zone);
+        equal(time.timezoneOffset, UTC_MINUS_430, time.toString());
+    }
+
+    for (let month = JANUARY; month <= APRIL; month++) {
+        time.resetTo(2016, month, 1, 0, 0, 0, zone);
+        equal(time.timezoneOffset, UTC_MINUS_430, time.toString());
+    }
+
+    time.resetTo(2016, MAY, 1, 1, 0, 0, zone);
+    equal(time.timezoneOffset, UTC_MINUS_430, time.toString());
+
+    time.resetTo(2016, MAY, 1, 3, 0, 0, zone);
+    equal(time.timezoneOffset, UTC_MINUS_4, time.toString());
+
+    for (let month = JUNE; month <= DECEMBER; month++) {
+        time.resetTo(2016, month, 1, 0, 0, 0, zone);
+        equal(time.timezoneOffset, UTC_MINUS_4, time.toString());
+    }
+
+    for (let month = JANUARY; month <= DECEMBER; month++) {
+        time.resetTo(2017, month, 1, 0, 0, 0, zone);
+        equal(time.timezoneOffset, UTC_MINUS_4, time.toString());
+    }
+
+    run_next_test();
+}); */
+
+// Brazil's rules are complicated. This tests every change in the time range we have data for.
+// Updated for 2019b: Brazil no longer has DST.
+add_test(function testSaoPaulo() {
+  let time = cal.createDateTime();
+  let zone = cal.timezoneService.getTimezone("America/Sao_Paulo");
+
+  time.resetTo(2018, FEBRUARY, 17, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_2, time.toString());
+
+  time.resetTo(2018, FEBRUARY, 18, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_3, time.toString());
+
+  time.resetTo(2018, NOVEMBER, 3, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_3, time.toString());
+
+  time.resetTo(2018, NOVEMBER, 4, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_2, time.toString());
+
+  time.resetTo(2019, FEBRUARY, 16, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_2, time.toString());
+
+  time.resetTo(2019, FEBRUARY, 17, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_3, time.toString());
+
+  time.resetTo(2019, NOVEMBER, 2, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_3, time.toString());
+
+  time.resetTo(2019, NOVEMBER, 3, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_3, time.toString());
+
+  time.resetTo(2020, FEBRUARY, 15, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_3, time.toString());
+
+  time.resetTo(2020, FEBRUARY, 16, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_3, time.toString());
+
+  time.resetTo(2020, OCTOBER, 31, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_3, time.toString());
+
+  time.resetTo(2020, NOVEMBER, 1, 0, 0, 0, zone);
+  equal(time.timezoneOffset, UTC_MINUS_3, time.toString());
+
+  run_next_test();
+});
diff --git a/comm/calendar/test/unit/test_timezone_definition.js b/comm/calendar/test/unit/test_timezone_definition.js
new file mode 100644
index 0000000000..79cddc2245
--- /dev/null
+++ b/comm/calendar/test/unit/test_timezone_definition.js
@@ -0,0 +1,32 @@
+/* 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 run_test() {
+  do_calendar_startup(run_next_test);
+}
+
+// check tz database version
+add_task(async function version_test() {
+  ok(cal.timezoneService.version, "service should provide timezone version");
+});
+
+// check whether all tz definitions have all properties
+add_task(async function zone_test() {
+  function resolveZone(aZoneId) {
+    let timezone = cal.timezoneService.getTimezone(aZoneId);
+    equal(aZoneId, timezone.tzid, "Zone test " + aZoneId);
+    ok(
+      timezone.icalComponent.serializeToICS().startsWith("BEGIN:VTIMEZONE"),
+      "VTIMEZONE test " + aZoneId
+    );
+  }
+
+  let foundZone = false;
+  for (let zone of cal.timezoneService.timezoneIds) {
+    foundZone = true;
+    resolveZone(zone);
+  }
+
+  ok(foundZone, "There is at least one timezone");
+});
diff --git a/comm/calendar/test/unit/test_transaction_manager.js b/comm/calendar/test/unit/test_transaction_manager.js
new file mode 100644
index 0000000000..bd9c591560
--- /dev/null
+++ b/comm/calendar/test/unit/test_transaction_manager.js
@@ -0,0 +1,431 @@
+/* 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/. */
+
+/**
+ * Tests for the CalTransactionManager and the various CalTransaction instances.
+ */
+
+const { CalendarTestUtils } = ChromeUtils.import(
+  "resource://testing-common/calendar/CalendarTestUtils.jsm"
+);
+const { CalEvent } = ChromeUtils.import("resource:///modules/CalEvent.jsm");
+const { CalTodo } = ChromeUtils.import("resource:///modules/CalTodo.jsm");
+const {
+  CalTransactionManager,
+  CalTransaction,
+  CalBatchTransaction,
+  CalAddTransaction,
+  CalModifyTransaction,
+  CalDeleteTransaction,
+} = ChromeUtils.import("resource:///modules/CalTransactionManager.jsm");
+
+/**
+ * Records the number of times doTransction() and undoTransction() is called.
+ */
+class MockCalTransaction extends CalTransaction {
+  /**
+   * The number of times doTransaction() was called.
+   *
+   * @type {number}
+   */
+  done = 0;
+
+  /**
+   * The number of times undoTransaction() was called.
+   */
+  undone = 0;
+
+  _writable;
+
+  constructor(writable = true) {
+    super();
+    this._writable = writable;
+  }
+
+  canWrite() {
+    return this._writable;
+  }
+
+  async doTransaction() {
+    this.done++;
+  }
+
+  async undoTransaction() {
+    this.undone++;
+  }
+}
+
+/**
+ * Tests a list of CalMockTransactions have the expected "done" and "undone"
+ * values.
+ *
+ * @param {CalMockTransaction[][]} batches The transaction batches to check.
+ * @param {number[][][]} expected - A 3 dimensional array containing
+ *  the expected "done" and "undone" values for each transaction in each batch
+ *  to be tested.
+ */
+function doBatchTest(batches, expected) {
+  for (let [batch, transactions] of batches.entries()) {
+    for (let [index, trn] of transactions.entries()) {
+      let [doneCount, undoneCount] = expected[batch][index];
+      Assert.equal(
+        trn.done,
+        doneCount,
+        `batch ${batch}, transaction ${index} doTransaction() called ${doneCount} times`
+      );
+      Assert.equal(
+        trn.undone,
+        undoneCount,
+        `batch ${batch}, transaction ${index} undoTransaction() called ${undoneCount} times`
+      );
+    }
+  }
+}
+
+add_setup(async function () {
+  await new Promise(resolve => do_load_calmgr(resolve));
+});
+
+/**
+ * Tests the CalTransactionManager methods work as expected.
+ */
+add_task(async function testCalTransactionManager() {
+  let manager = new CalTransactionManager();
+
+  Assert.ok(!manager.canUndo(), "canUndo() returns false with an empty undo stack");
+  Assert.ok(!manager.canRedo(), "canRedo() returns false with an empty redo stack");
+  Assert.ok(!manager.peekUndoStack(), "peekUndoStack() returns nothing with an empty undo stack");
+  Assert.ok(!manager.peekRedoStack(), "peekRedoStack() returns nothing with an empty redo stack");
+
+  info("calling CalTransactionManager.commit()");
+  let trn = new MockCalTransaction();
+  await manager.commit(trn);
+  Assert.equal(trn.done, 1, "doTransaction() called once");
+  Assert.equal(trn.undone, 0, "undoTransaction() was not called");
+  Assert.ok(manager.canUndo(), "canUndo() returned true");
+  Assert.ok(!manager.canRedo(), "canRedo() returned false");
+  Assert.equal(manager.peekUndoStack(), trn, "peekUndoStack() returned the transaction");
+  Assert.ok(!manager.peekRedoStack(), "peekRedoStack() returned nothing");
+
+  info("calling CalTransactionManager.undo()");
+  await manager.undo();
+  Assert.equal(trn.done, 1, "doTransaction() was not called again");
+  Assert.equal(trn.undone, 1, "undoTransaction() was called once");
+  Assert.ok(!manager.canUndo(), "canUndo() returned false");
+  Assert.ok(manager.canRedo(), "canRedo() returned true");
+  Assert.ok(!manager.peekUndoStack(), "peekUndoStack() returned nothing");
+  Assert.equal(manager.peekRedoStack(), trn, "peekRedoStack() returned the transaction");
+
+  info("calling CalTransactionManager.redo()");
+  await manager.redo();
+  Assert.equal(trn.done, 2, "doTransaction() was called again");
+  Assert.equal(trn.undone, 1, "undoTransaction() was not called again");
+  Assert.ok(manager.canUndo(), "canUndo() returned true");
+  Assert.ok(!manager.canRedo(), "canRedo() returned false");
+  Assert.equal(manager.peekUndoStack(), trn, "peekUndoStack() returned the transaction");
+  Assert.ok(!manager.peekRedoStack(), "peekRedoStack() returned nothing");
+
+  info("testing CalTransactionManager.beginBatch()");
+  manager = new CalTransactionManager();
+
+  let batch = manager.beginBatch();
+  Assert.ok(batch instanceof CalBatchTransaction, "beginBatch() returned a CalBatchTransaction");
+  Assert.equal(manager.undoStack[0], batch, "the CalBatchTransaction is on the undo stack");
+});
+
+/**
+ * Tests the BatchTransaction works as expected.
+ */
+add_task(async function testBatchTransaction() {
+  let batch = new CalBatchTransaction();
+
+  Assert.ok(!batch.canWrite(), "canWrite() returns false for an empty BatchTransaction");
+  await batch.commit(new MockCalTransaction());
+  await batch.commit(new MockCalTransaction(false));
+  await batch.commit(new MockCalTransaction());
+  Assert.ok(!batch.canWrite(), "canWrite() returns false if any transaction is not writable");
+
+  let transactions = [new MockCalTransaction(), new MockCalTransaction(), new MockCalTransaction()];
+  batch = new CalBatchTransaction();
+  for (let trn of transactions) {
+    await batch.commit(trn);
+  }
+
+  Assert.ok(batch.canWrite(), "canWrite() returns true when all transactions are writable");
+  info("testing commit() calls doTransaction() on each transaction in batch");
+  doBatchTest(
+    [transactions],
+    [
+      [
+        [1, 0],
+        [1, 0],
+        [1, 0],
+      ],
+    ]
+  );
+
+  await batch.undoTransaction();
+  info("testing undoTransaction() called on each transaction in batch");
+  doBatchTest(
+    [transactions],
+    [
+      [
+        [1, 1],
+        [1, 1],
+        [1, 1],
+      ],
+    ]
+  );
+
+  await batch.doTransaction();
+  info("testing doTransaction() called again on each transaction in batch");
+  doBatchTest(
+    [transactions],
+    [
+      [
+        [2, 1],
+        [2, 1],
+        [2, 1],
+      ],
+    ]
+  );
+});
+
+/**
+ * Tests that executing multiple batch transactions in sequence works.
+ */
+add_task(async function testSequentialBatchTransactions() {
+  let manager = new CalTransactionManager();
+
+  let batchTransactions = [
+    [new MockCalTransaction(), new MockCalTransaction(), new MockCalTransaction()],
+    [new MockCalTransaction(), new MockCalTransaction(), new MockCalTransaction()],
+    [new MockCalTransaction(), new MockCalTransaction(), new MockCalTransaction()],
+  ];
+
+  let batch0 = manager.beginBatch();
+  for (let trn of batchTransactions[0]) {
+    await batch0.commit(trn);
+  }
+
+  let batch1 = manager.beginBatch();
+  for (let trn of batchTransactions[1]) {
+    await batch1.commit(trn);
+  }
+
+  let batch2 = manager.beginBatch();
+  for (let trn of batchTransactions[2]) {
+    await batch2.commit(trn);
+  }
+
+  doBatchTest(batchTransactions, [
+    [
+      [1, 0],
+      [1, 0],
+      [1, 0],
+    ],
+    [
+      [1, 0],
+      [1, 0],
+      [1, 0],
+    ],
+    [
+      [1, 0],
+      [1, 0],
+      [1, 0],
+    ],
+  ]);
+
+  // Undo the top most batch.
+  await manager.undo();
+  doBatchTest(batchTransactions, [
+    [
+      [1, 0],
+      [1, 0],
+      [1, 0],
+    ],
+    [
+      [1, 0],
+      [1, 0],
+      [1, 0],
+    ],
+    [
+      [1, 1],
+      [1, 1],
+      [1, 1],
+    ],
+  ]);
+
+  // Undo the next batch.
+  await manager.undo();
+  doBatchTest(batchTransactions, [
+    [
+      [1, 0],
+      [1, 0],
+      [1, 0],
+    ],
+    [
+      [1, 1],
+      [1, 1],
+      [1, 1],
+    ],
+    [
+      [1, 1],
+      [1, 1],
+      [1, 1],
+    ],
+  ]);
+
+  // Undo the last batch left.
+  await manager.undo();
+  doBatchTest(batchTransactions, [
+    [
+      [1, 1],
+      [1, 1],
+      [1, 1],
+    ],
+    [
+      [1, 1],
+      [1, 1],
+      [1, 1],
+    ],
+    [
+      [1, 1],
+      [1, 1],
+      [1, 1],
+    ],
+  ]);
+
+  // Redo the first batch.
+  await manager.redo();
+  doBatchTest(batchTransactions, [
+    [
+      [2, 1],
+      [2, 1],
+      [2, 1],
+    ],
+    [
+      [1, 1],
+      [1, 1],
+      [1, 1],
+    ],
+    [
+      [1, 1],
+      [1, 1],
+      [1, 1],
+    ],
+  ]);
+
+  // Redo the second batch.
+  await manager.redo();
+  doBatchTest(batchTransactions, [
+    [
+      [2, 1],
+      [2, 1],
+      [2, 1],
+    ],
+    [
+      [2, 1],
+      [2, 1],
+      [2, 1],
+    ],
+    [
+      [1, 1],
+      [1, 1],
+      [1, 1],
+    ],
+  ]);
+
+  // Redo the last batch.
+  await manager.redo();
+  doBatchTest(batchTransactions, [
+    [
+      [2, 1],
+      [2, 1],
+      [2, 1],
+    ],
+    [
+      [2, 1],
+      [2, 1],
+      [2, 1],
+    ],
+    [
+      [2, 1],
+      [2, 1],
+      [2, 1],
+    ],
+  ]);
+});
+
+/**
+ * Tests CalAddTransaction executes and reverses as expected.
+ */
+add_task(async function testCalAddTransaction() {
+  let calendar = CalendarTestUtils.createCalendar("Test", "memory");
+  let event = new CalEvent();
+  event.id = "test";
+
+  let trn = new CalAddTransaction(event, calendar, null, null);
+  await trn.doTransaction();
+
+  let addedEvent = await calendar.getItem("test");
+  Assert.ok(!!addedEvent, "transaction added event to the calendar");
+
+  await trn.undoTransaction();
+  addedEvent = await calendar.getItem("test");
+  Assert.ok(!addedEvent, "transaction removed event from the calendar");
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+/**
+ * Tests CalModifyTransaction executes and reverses as expected.
+ */
+add_task(async function testCalModifyTransaction() {
+  let calendar = CalendarTestUtils.createCalendar("Test", "memory");
+  let event = new CalEvent();
+  event.id = "test";
+  event.title = "Event";
+
+  let addedEvent = await calendar.addItem(event);
+  Assert.ok(!!addedEvent, "event was added to the calendar");
+
+  let modifiedEvent = addedEvent.clone();
+  modifiedEvent.title = "Modified Event";
+
+  let trn = new CalModifyTransaction(modifiedEvent, calendar, addedEvent, null);
+  await trn.doTransaction();
+  modifiedEvent = await calendar.getItem("test");
+  Assert.ok(!!modifiedEvent);
+  Assert.equal(modifiedEvent.title, "Modified Event", "transaction modified event");
+
+  await trn.undoTransaction();
+  let revertedEvent = await calendar.getItem("test");
+  Assert.ok(!!revertedEvent);
+  Assert.equal(revertedEvent.title, "Event", "transaction reverted event to original state");
+  CalendarTestUtils.removeCalendar(calendar);
+});
+
+/**
+ * Tests CalDeleteTransaction executes and reverses as expected.
+ */
+add_task(async function testCalDeleteTransaction() {
+  let calendar = CalendarTestUtils.createCalendar("Test", "memory");
+  let event = new CalEvent();
+  event.id = "test";
+  event.title = "Event";
+
+  let addedEvent = await calendar.addItem(event);
+  Assert.ok(!!addedEvent, "event was added to the calendar");
+
+  let trn = new CalDeleteTransaction(addedEvent, calendar, null, null);
+  await trn.doTransaction();
+
+  let result = await calendar.getItem("test");
+  Assert.ok(!result, "event was deleted from the calendar");
+
+  await trn.undoTransaction();
+  let revertedEvent = await calendar.getItem("test");
+  Assert.ok(!!revertedEvent, "event was restored to the calendar");
+  CalendarTestUtils.removeCalendar(calendar);
+});
diff --git a/comm/calendar/test/unit/test_unifinder_utils.js b/comm/calendar/test/unit/test_unifinder_utils.js
new file mode 100644
index 0000000000..ae44379781
--- /dev/null
+++ b/comm/calendar/test/unit/test_unifinder_utils.js
@@ -0,0 +1,137 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalTodo: "resource:///modules/CalTodo.jsm",
+});
+
+function run_test() {
+  test_get_item_sort_key();
+  test_sort_items();
+}
+
+function test_get_item_sort_key() {
+  let event = new CalEvent(dedent`
+        BEGIN:VEVENT
+        PRIORITY:8
+        SUMMARY:summary
+        DTSTART:20180102T030405Z
+        DTEND:20180607T080910Z
+        CATEGORIES:a,b,c
+        LOCATION:location
+        STATUS:CONFIRMED
+        END:VEVENT
+    `);
+
+  strictEqual(cal.unifinder.getItemSortKey(event, "nothing"), null);
+  equal(cal.unifinder.getItemSortKey(event, "priority"), 8);
+  equal(cal.unifinder.getItemSortKey(event, "title"), "summary");
+  equal(cal.unifinder.getItemSortKey(event, "startDate"), 1514862245000000);
+  equal(cal.unifinder.getItemSortKey(event, "endDate"), 1528358950000000);
+  equal(cal.unifinder.getItemSortKey(event, "categories"), "a, b, c");
+  equal(cal.unifinder.getItemSortKey(event, "location"), "location");
+  equal(cal.unifinder.getItemSortKey(event, "status"), 1);
+
+  let task = new CalTodo(dedent`
+        BEGIN:VTODO
+        DTSTART:20180102T030405Z
+        DUE:20180607T080910Z
+        PERCENT-COMPLETE:20
+        STATUS:COMPLETED
+        END:VTODO
+    `);
+
+  equal(cal.unifinder.getItemSortKey(task, "priority"), 5);
+  strictEqual(cal.unifinder.getItemSortKey(task, "title"), "");
+  equal(cal.unifinder.getItemSortKey(task, "entryDate"), 1514862245000000);
+  equal(cal.unifinder.getItemSortKey(task, "dueDate"), 1528358950000000);
+  equal(cal.unifinder.getItemSortKey(task, "completedDate"), -62168601600000000);
+  equal(cal.unifinder.getItemSortKey(task, "percentComplete"), 20);
+  strictEqual(cal.unifinder.getItemSortKey(task, "categories"), "");
+  strictEqual(cal.unifinder.getItemSortKey(task, "location"), "");
+  equal(cal.unifinder.getItemSortKey(task, "status"), 2);
+
+  let task2 = new CalTodo(dedent`
+        BEGIN:VTODO
+        STATUS:GETTIN' THERE
+        END:VTODO
+    `);
+  equal(cal.unifinder.getItemSortKey(task2, "percentComplete"), 0);
+  equal(cal.unifinder.getItemSortKey(task2, "status"), -1);
+
+  // Default CalTodo objects have the default percentComplete.
+  let task3 = new CalTodo();
+  equal(cal.unifinder.getItemSortKey(task3, "percentComplete"), 0);
+}
+
+function test_sort_items() {
+  // string comparison
+  let summaries = ["", "a", "b"];
+  let items = summaries.map(summary => {
+    return new CalEvent(dedent`
+            BEGIN:VEVENT
+            SUMMARY:${summary}
+            END:VEVENT
+        `);
+  });
+
+  cal.unifinder.sortItems(items, "title", 1);
+  deepEqual(
+    items.map(item => item.title),
+    ["a", "b", null]
+  );
+
+  cal.unifinder.sortItems(items, "title", -1);
+  deepEqual(
+    items.map(item => item.title),
+    [null, "b", "a"]
+  );
+
+  // date comparison
+  let dates = ["20180101T000002Z", "20180101T000000Z", "20180101T000001Z"];
+  items = dates.map(date => {
+    return new CalEvent(dedent`
+            BEGIN:VEVENT
+            DTSTART:${date}
+            END:VEVENT
+        `);
+  });
+
+  cal.unifinder.sortItems(items, "startDate", 1);
+  deepEqual(
+    items.map(item => item.startDate.icalString),
+    ["20180101T000000Z", "20180101T000001Z", "20180101T000002Z"]
+  );
+
+  cal.unifinder.sortItems(items, "startDate", -1);
+  deepEqual(
+    items.map(item => item.startDate.icalString),
+    ["20180101T000002Z", "20180101T000001Z", "20180101T000000Z"]
+  );
+
+  // number comparison
+  let percents = [3, 1, 2];
+  items = percents.map(percent => {
+    return new CalTodo(dedent`
+            BEGIN:VTODO
+            PERCENT-COMPLETE:${percent}
+            END:VTODO
+        `);
+  });
+
+  cal.unifinder.sortItems(items, "percentComplete", 1);
+  deepEqual(
+    items.map(item => item.percentComplete),
+    [1, 2, 3]
+  );
+
+  cal.unifinder.sortItems(items, "percentComplete", -1);
+  deepEqual(
+    items.map(item => item.percentComplete),
+    [3, 2, 1]
+  );
+}
diff --git a/comm/calendar/test/unit/test_utils.js b/comm/calendar/test/unit/test_utils.js
new file mode 100644
index 0000000000..05d7423808
--- /dev/null
+++ b/comm/calendar/test/unit/test_utils.js
@@ -0,0 +1,185 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalTodo: "resource:///modules/CalTodo.jsm",
+});
+
+function run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  test_recentzones();
+  test_formatcss();
+  test_getDefaultStartDate();
+  test_getStartEndProps();
+  test_OperationGroup();
+  test_sameDay();
+  test_binarySearch();
+}
+
+function test_recentzones() {
+  equal(cal.dtz.getRecentTimezones().length, 0);
+  equal(cal.dtz.getRecentTimezones(true).length, 0);
+
+  cal.dtz.saveRecentTimezone("Europe/Berlin");
+
+  let zones = cal.dtz.getRecentTimezones();
+  equal(zones.length, 1);
+  equal(zones[0], "Europe/Berlin");
+  zones = cal.dtz.getRecentTimezones(true);
+  equal(zones.length, 1);
+  equal(zones[0].tzid, "Europe/Berlin");
+
+  cal.dtz.saveRecentTimezone(cal.dtz.defaultTimezone.tzid);
+  equal(cal.dtz.getRecentTimezones().length, 1);
+  equal(cal.dtz.getRecentTimezones(true).length, 1);
+
+  cal.dtz.saveRecentTimezone("Europe/Berlin");
+  equal(cal.dtz.getRecentTimezones().length, 1);
+  equal(cal.dtz.getRecentTimezones(true).length, 1);
+
+  cal.dtz.saveRecentTimezone("America/New_York");
+  equal(cal.dtz.getRecentTimezones().length, 2);
+  equal(cal.dtz.getRecentTimezones(true).length, 2);
+
+  cal.dtz.saveRecentTimezone("Unknown");
+  equal(cal.dtz.getRecentTimezones().length, 3);
+  equal(cal.dtz.getRecentTimezones(true).length, 2);
+}
+
+function test_formatcss() {
+  equal(cal.view.formatStringForCSSRule(" "), "_");
+  equal(cal.view.formatStringForCSSRule("ü"), "-uxfc-");
+  equal(cal.view.formatStringForCSSRule("a"), "a");
+}
+
+function test_getDefaultStartDate() {
+  function transform(nowString, refDateString) {
+    now = cal.createDateTime(nowString);
+    let refDate = refDateString ? cal.createDateTime(refDateString) : null;
+    return cal.dtz.getDefaultStartDate(refDate);
+  }
+
+  let oldNow = cal.dtz.now;
+  let now = cal.createDateTime("20120101T000000");
+  cal.dtz.now = function () {
+    return now;
+  };
+
+  dump("TT: " + cal.createDateTime("20120101T000000") + "\n");
+  dump("TT: " + cal.dtz.getDefaultStartDate(cal.createDateTime("20120101T000000")) + "\n");
+
+  equal(transform("20120101T000000").icalString, "20120101T010000");
+  equal(transform("20120101T015959").icalString, "20120101T020000");
+  equal(transform("20120101T230000").icalString, "20120101T230000");
+  equal(transform("20120101T235959").icalString, "20120101T230000");
+
+  equal(transform("20120101T000000", "20120202").icalString, "20120202T010000");
+  equal(transform("20120101T015959", "20120202").icalString, "20120202T020000");
+  equal(transform("20120101T230000", "20120202").icalString, "20120202T230000");
+  equal(transform("20120101T235959", "20120202").icalString, "20120202T230000");
+
+  let event = new CalEvent();
+  now = cal.createDateTime("20120101T015959");
+  cal.dtz.setDefaultStartEndHour(event, cal.createDateTime("20120202"));
+  equal(event.startDate.icalString, "20120202T020000");
+  equal(event.endDate.icalString, "20120202T030000");
+
+  let todo = new CalTodo();
+  now = cal.createDateTime("20120101T000000");
+  cal.dtz.setDefaultStartEndHour(todo, cal.createDateTime("20120202"));
+  equal(todo.entryDate.icalString, "20120202T010000");
+
+  cal.dtz.now = oldNow;
+}
+
+function test_getStartEndProps() {
+  equal(cal.dtz.startDateProp(new CalEvent()), "startDate");
+  equal(cal.dtz.endDateProp(new CalEvent()), "endDate");
+  equal(cal.dtz.startDateProp(new CalTodo()), "entryDate");
+  equal(cal.dtz.endDateProp(new CalTodo()), "dueDate");
+
+  throws(() => cal.dtz.startDateProp(null), /NS_ERROR_NOT_IMPLEMENTED/);
+  throws(() => cal.dtz.endDateProp(null), /NS_ERROR_NOT_IMPLEMENTED/);
+}
+
+function test_OperationGroup() {
+  let cancelCalled = false;
+  function cancelFunc() {
+    cancelCalled = true;
+    return true;
+  }
+
+  let group = new cal.data.OperationGroup(cancelFunc);
+
+  ok(group.isEmpty);
+  ok(group.id.endsWith("-0"));
+  equal(group.status, Cr.NS_OK);
+  equal(group.isPending, true);
+
+  let completedOp = { isPending: false };
+
+  group.add(completedOp);
+  ok(group.isEmpty);
+  equal(group.isPending, true);
+
+  let pendingOp1 = {
+    id: 1,
+    isPending: true,
+    cancel() {
+      this.cancelCalled = true;
+      return true;
+    },
+  };
+
+  group.add(pendingOp1);
+  ok(!group.isEmpty);
+  equal(group.isPending, true);
+
+  let pendingOp2 = {
+    id: 2,
+    isPending: true,
+    cancel() {
+      this.cancelCalled = true;
+      return true;
+    },
+  };
+
+  group.add(pendingOp2);
+  group.remove(pendingOp1);
+  ok(!group.isEmpty);
+  equal(group.isPending, true);
+
+  group.cancel();
+
+  equal(group.status, Ci.calIErrors.OPERATION_CANCELLED);
+  ok(!group.isPending);
+  ok(cancelCalled);
+  ok(pendingOp2.cancelCalled);
+}
+
+function test_sameDay() {
+  let createDate = cal.createDateTime.bind(cal);
+
+  ok(cal.dtz.sameDay(createDate("20120101"), createDate("20120101T120000")));
+  ok(cal.dtz.sameDay(createDate("20120101"), createDate("20120101")));
+  ok(!cal.dtz.sameDay(createDate("20120101"), createDate("20120102")));
+  ok(!cal.dtz.sameDay(createDate("20120101T120000"), createDate("20120102T120000")));
+}
+
+function test_binarySearch() {
+  let arr = [2, 5, 7, 9, 20, 27, 34, 39, 41, 53, 62];
+  equal(cal.data.binarySearch(arr, 27), 5); // Center
+  equal(cal.data.binarySearch(arr, 2), 0); // Left most
+  equal(cal.data.binarySearch(arr, 62), 11); // Right most
+
+  equal(cal.data.binarySearch([5], 5), 1); // One element found
+  equal(cal.data.binarySearch([1], 0), 0); // One element insert left
+  equal(cal.data.binarySearch([1], 2), 1); // One element insert right
+}
diff --git a/comm/calendar/test/unit/test_view_utils.js b/comm/calendar/test/unit/test_view_utils.js
new file mode 100644
index 0000000000..da988f8042
--- /dev/null
+++ b/comm/calendar/test/unit/test_view_utils.js
@@ -0,0 +1,127 @@
+/* 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 { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalTodo: "resource:///modules/CalTodo.jsm",
+});
+
+function run_test() {
+  do_calendar_startup(really_run_test);
+}
+
+function really_run_test() {
+  test_not_a_date();
+  test_compare_event_and_todo();
+  test_compare_startdate();
+  test_compare_enddate();
+  test_compare_alldayevent();
+  test_compare_title();
+  test_compare_todo();
+}
+
+function test_not_a_date() {
+  let item = new CalEvent();
+
+  let result = cal.view.compareItems(null, item);
+  equal(result, -1);
+
+  result = cal.view.compareItems(item, null);
+  equal(result, 1);
+}
+
+function test_compare_event_and_todo() {
+  let a = new CalEvent();
+  let b = new CalTodo();
+
+  let result = cal.view.compareItems(a, b);
+  equal(result, 1);
+
+  result = cal.view.compareItems(b, a);
+  equal(result, -1);
+}
+
+function test_compare_startdate() {
+  let a = new CalEvent();
+  a.startDate = createDate(1990, 0, 1, 1);
+  let b = new CalEvent();
+  b.startDate = createDate(2000, 0, 1, 1);
+
+  let result = cal.view.compareItems(a, b);
+  equal(result, -1);
+
+  result = cal.view.compareItems(b, a);
+  equal(result, 1);
+
+  result = cal.view.compareItems(a, a);
+  equal(result, 0);
+}
+
+function test_compare_enddate() {
+  let a = new CalEvent();
+  a.startDate = createDate(1990, 0, 1, 1);
+  a.endDate = createDate(1990, 0, 2, 1);
+  let b = new CalEvent();
+  b.startDate = createDate(1990, 0, 1, 1);
+  b.endDate = createDate(1990, 0, 5, 1);
+
+  let result = cal.view.compareItems(a, b);
+  equal(result, -1);
+
+  result = cal.view.compareItems(b, a);
+  equal(result, 1);
+
+  result = cal.view.compareItems(a, a);
+  equal(result, 0);
+}
+
+function test_compare_alldayevent() {
+  let a = new CalEvent();
+  a.startDate = createDate(1990, 0, 1);
+  let b = new CalEvent();
+  b.startDate = createDate(1990, 0, 1, 1);
+
+  let result = cal.view.compareItems(a, b);
+  equal(result, -1);
+
+  result = cal.view.compareItems(b, a);
+  equal(result, 1);
+
+  result = cal.view.compareItems(a, a);
+  equal(result, 0);
+}
+
+function test_compare_title() {
+  let a = new CalEvent();
+  a.startDate = createDate(1990, 0, 1);
+  a.title = "Abc";
+  let b = new CalEvent();
+  b.startDate = createDate(1990, 0, 1);
+  b.title = "Xyz";
+
+  let result = cal.view.compareItems(a, b);
+  equal(result, -1);
+
+  result = cal.view.compareItems(b, a);
+  equal(result, 1);
+
+  result = cal.view.compareItems(a, a);
+  equal(result, 0);
+}
+
+function test_compare_todo() {
+  let a = new CalTodo();
+  let b = new CalTodo();
+
+  let cmp = cal.view.compareItems(a, b);
+  equal(cmp, 0);
+
+  cmp = cal.view.compareItems(b, a);
+  equal(cmp, 0);
+
+  cmp = cal.view.compareItems(a, a);
+  equal(cmp, 0);
+}
diff --git a/comm/calendar/test/unit/test_webcal.js b/comm/calendar/test/unit/test_webcal.js
new file mode 100644
index 0000000000..77d9576f4b
--- /dev/null
+++ b/comm/calendar/test/unit/test_webcal.js
@@ -0,0 +1,44 @@
+/* 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 { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+var { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
+
+function run_test() {
+  let httpserv = new HttpServer();
+  httpserv.registerPrefixHandler("/", {
+    handle(request, response) {
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      equal(request.path, "/test_webcal");
+    },
+  });
+  httpserv.start(-1);
+
+  let baseUri = "://localhost:" + httpserv.identity.primaryPort + "/test_webcal";
+  add_test(check_webcal_uri.bind(null, "webcal" + baseUri));
+  // TODO webcals needs bug 466524 to be fixed
+  // add_test(check_webcal_uri.bind(null, "webcals" + baseUri));
+  add_test(() => httpserv.stop(run_next_test));
+
+  // Now lets go...
+  run_next_test();
+}
+
+function check_webcal_uri(aUri) {
+  let uri = Services.io.newURI(aUri);
+
+  let channel = Services.io.newChannelFromURI(
+    uri,
+    null,
+    Services.scriptSecurityManager.getSystemPrincipal(),
+    null,
+    Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+    Ci.nsIContentPolicy.TYPE_OTHER
+  );
+
+  NetUtil.asyncFetch(channel, (data, status, request) => {
+    ok(Components.isSuccessCode(status));
+    run_next_test();
+  });
+}
diff --git a/comm/calendar/test/unit/test_weekinfo_service.js b/comm/calendar/test/unit/test_weekinfo_service.js
new file mode 100644
index 0000000000..9be4d02dd3
--- /dev/null
+++ b/comm/calendar/test/unit/test_weekinfo_service.js
@@ -0,0 +1,33 @@
+/* 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 run_test() {
+  // Bug 1239622. The 1st of January after a leap year which ends with
+  // a Thursday belongs to week number 53 unless the start of week is
+  // set on Friday.
+  let wkst_wknum_date = [
+    [1, 53, "20210101T000000Z"], // Year 2021 affected by Bug 1239622
+    [5, 1, "20210101T000000Z"], //
+    [3, 53, "20490101T000000Z"], // Year 2049 affected by Bug 1239622
+    [5, 1, "20490101T000000Z"], //
+    [0, 1, "20170101T000000Z"], // Year that starts on Sunday ...
+    [3, 52, "20180101T000000Z"], // ... Monday
+    [0, 1, "20190101T000000Z"], // ... Tuesday
+    [4, 52, "20200101T000000Z"], // ... Wednesday
+    [0, 1, "20260101T000000Z"], // ... Thursday
+    [0, 53, "20270101T000000Z"], // ... Friday
+    [0, 52, "20280101T000000Z"],
+  ]; // ... Saturday
+
+  let savedWeekStart = Services.prefs.getIntPref("calendar.week.start", 0);
+  for (let [weekStart, weekNumber, dateString] of wkst_wknum_date) {
+    Services.prefs.setIntPref("calendar.week.start", weekStart);
+    let date = cal.createDateTime(dateString);
+    date.isDate = true;
+    let week = cal.weekInfoService.getWeekTitle(date);
+
+    equal(week, weekNumber, "Week number matches for " + dateString);
+  }
+  Services.prefs.setIntPref("calendar.week.start", savedWeekStart);
+}
diff --git a/comm/calendar/test/unit/xpcshell.ini b/comm/calendar/test/unit/xpcshell.ini
new file mode 100644
index 0000000000..2d4639d0b6
--- /dev/null
+++ b/comm/calendar/test/unit/xpcshell.ini
@@ -0,0 +1,82 @@
+[DEFAULT]
+head = head.js
+prefs =
+  calendar.timezone.local=UTC
+  calendar.timezone.useSystemTimezone=false
+  calendar.itip.updateInvitationForNewAttendeesOnly=true
+support-files = data/**
+tags = calendar
+
+[test_alarm.js]
+[test_alarmservice.js]
+[test_alarmutils.js]
+[test_attachment.js]
+[test_attendee.js]
+[test_auth_utils.js]
+[test_bug1199942.js]
+[test_bug1204255.js]
+[test_bug1209399.js]
+[test_bug1790339.js]
+[test_bug272411.js]
+[test_bug343792.js]
+[test_bug350845.js]
+[test_bug356207.js]
+[test_bug485571.js]
+[test_bug486186.js]
+[test_bug494140.js]
+[test_bug523860.js]
+[test_bug653924.js]
+[test_bug668222.js]
+[test_bug759324.js]
+[test_caldav_requests.js]
+[test_CalendarFileImporter.js]
+[test_calIteratorUtils.js]
+[test_calmgr.js]
+[test_calreadablestreamfactory.js]
+[test_calStorageHelpers.js]
+[test_data_bags.js]
+[test_datetime.js]
+[test_datetime_before_1970.js]
+[test_datetimeformatter.js]
+[test_deleted_items.js]
+[test_duration.js]
+[test_email_utils.js]
+[test_extract.js]
+[test_extract_parser.js]
+[test_extract_parser_parse.js]
+[test_extract_parser_service.js]
+[test_extract_parser_tokenize.js]
+[test_filter.js]
+[test_filter_mixin.js]
+[test_filter_tree_view.js]
+[test_freebusy.js]
+[test_freebusy_service.js]
+[test_hashedarray.js]
+[test_ics.js]
+[test_ics_parser.js]
+[test_ics_service.js]
+[test_imip.js]
+[test_invitationutils.js]
+[test_items.js]
+[test_itip_message_sender.js]
+[test_itip_utils.js]
+[test_l10n_utils.js]
+[test_lenient_parsing.js]
+[test_providers.js]
+[test_recur.js]
+[test_recurrence_utils.js]
+[test_relation.js]
+[test_rfc3339_parser.js]
+[test_startup_service.js]
+[test_storage.js]
+[test_storage_connection.js]
+[test_storage_get_items.js]
+[test_timezone.js]
+[test_timezone_changes.js]
+[test_timezone_definition.js]
+[test_transaction_manager.js]
+[test_unifinder_utils.js]
+[test_utils.js]
+[test_view_utils.js]
+[test_webcal.js]
+[test_weekinfo_service.js]