534 files changed, 134251 insertions, 0 deletions

diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/calendar-case-insensitive.js b/js/src/tests/test262/intl402/Temporal/Calendar/calendar-case-insensitive.js
new file mode 100644
index 0000000000..6fa399dd78
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/calendar-case-insensitive.js
@@ -0,0 +1,14 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar
+description: Calendar names are case-insensitive
+features: [Temporal]
+---*/
+
+const result = new Temporal.Calendar("jApAnEsE");
+assert.sameValue(result.toString(), "japanese", "Calendar is case-insensitive");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/from/basic.js b/js/src/tests/test262/intl402/Temporal/Calendar/from/basic.js
new file mode 100644
index 0000000000..196eea3ed5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/from/basic.js
@@ -0,0 +1,21 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.from
+description: Support for non-ISO calendars in Calendar.from().
+features: [Temporal]
+---*/
+
+function test(item, id = item) {
+  const calendar = Temporal.Calendar.from(item);
+  assert(calendar instanceof Temporal.Calendar, `Calendar.from(${item}) is a calendar`);
+  assert.sameValue(calendar.id, id, `Calendar.from(${item}) has the correct ID`);
+}
+test("gregory");
+test("japanese");
+test("1994-11-05T08:15:30-05:00[u-ca=gregory]", "gregory");
+test("1994-11-05T13:15:30Z[u-ca=japanese]", "japanese");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/from/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/from/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/from/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/from/calendar-case-insensitive.js b/js/src/tests/test262/intl402/Temporal/Calendar/from/calendar-case-insensitive.js
new file mode 100644
index 0000000000..1fb9adda6c
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/from/calendar-case-insensitive.js
@@ -0,0 +1,16 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.from
+description: Calendar names are case-insensitive
+features: [Temporal]
+---*/
+
+const arg = "jApAnEsE";
+
+const result = Temporal.Calendar.from(arg);
+assert.sameValue(result.id, "japanese", "Calendar is case-insensitive");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/from/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/from/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/from/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateAdd/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateAdd/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateAdd/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateAdd/date-infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateAdd/date-infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..dd39ea7730
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateAdd/date-infinity-throws-rangeerror.js
@@ -0,0 +1,26 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if any value in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.dateadd
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const duration = new Temporal.Duration(1);
+
+[Infinity, -Infinity].forEach((inf) => {
+  ["constrain", "reject"].forEach((overflow) => {
+    assert.throws(RangeError, () => instance.dateAdd({ era: "ad", eraYear: inf, month: 5, day: 2, calendar: instance }, duration, { overflow }), `eraYear property cannot be ${inf} (overflow ${overflow}`);
+
+    const calls = [];
+    const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+    assert.throws(RangeError, () => instance.dateAdd({ era: "ad", eraYear: obj, month: 5, day: 2, calendar: instance }, duration, { overflow }));
+    assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateAdd/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateAdd/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateAdd/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..e2d06d22f5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/infinity-throws-rangeerror.js
@@ -0,0 +1,26 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.datefromfields
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  ["constrain", "reject"].forEach((overflow) => {
+    assert.throws(RangeError, () => instance.dateFromFields({ ...base, eraYear: inf }, { overflow }), `eraYear property cannot be ${inf} (overflow ${overflow}`);
+
+    const calls = [];
+    const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+    assert.throws(RangeError, () => instance.dateFromFields({ ...base, eraYear: obj }, { overflow }));
+    assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/one-of-era-erayear-undefined.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/one-of-era-erayear-undefined.js
new file mode 100644
index 0000000000..be0d4e8a61
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/one-of-era-erayear-undefined.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.datefromfields
+description: Throw a TypeError if only one of era/eraYear fields is present
+features: [Temporal]
+---*/
+
+const base = { year: 2000, month: 5, day: 2, era: 'ce' };
+const instance = new Temporal.Calendar('gregory');
+assert.throws(TypeError, () => {
+  instance.dateFromFields({ ...base });
+});
+
+const base2 = { year: 2000, month: 5, day: 2, eraYear: 1 };
+assert.throws(TypeError, () => {
+  instance.dateFromFields({ ...base2 });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/order-of-operations.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/order-of-operations.js
new file mode 100644
index 0000000000..87db045a8d
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/order-of-operations.js
@@ -0,0 +1,79 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.datefromfields
+description: Properties on objects passed to dateFromFields() are accessed in the correct order
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const expected = [
+  "get fields.day",
+  "get fields.day.valueOf",
+  "call fields.day.valueOf",
+  "get fields.era",
+  "get fields.era.toString",
+  "call fields.era.toString",
+  "get fields.eraYear",
+  "get fields.eraYear.valueOf",
+  "call fields.eraYear.valueOf",
+  "get fields.month",
+  "get fields.month.valueOf",
+  "call fields.month.valueOf",
+  "get fields.monthCode",
+  "get fields.monthCode.toString",
+  "call fields.monthCode.toString",
+  "get fields.year",
+  "get fields.year.valueOf",
+  "call fields.year.valueOf",
+  "get options.overflow",
+  "get options.overflow.toString",
+  "call options.overflow.toString",
+];
+const actual = [];
+
+const instance = new Temporal.Calendar("gregory");
+
+const fields = {
+  era: "ce",
+  eraYear: 1.7,
+  year: 1.7,
+  month: 1.7,
+  monthCode: "M01",
+  day: 1.7,
+};
+const arg1 = new Proxy(fields, {
+  get(target, key) {
+    actual.push(`get fields.${key}`);
+    if (key === "calendar") return instance;
+    const result = target[key];
+    return TemporalHelpers.toPrimitiveObserver(actual, result, `fields.${key}`);
+  },
+  has(target, key) {
+    actual.push(`has fields.${key}`);
+    return key in target;
+  },
+});
+
+const options = {
+  overflow: "reject",
+};
+const arg2 = new Proxy(options, {
+  get(target, key) {
+    actual.push(`get options.${key}`);
+    return TemporalHelpers.toPrimitiveObserver(actual, target[key], `options.${key}`);
+  },
+  has(target, key) {
+    actual.push(`has options.${key}`);
+    return key in target;
+  },
+});
+
+const result = instance.dateFromFields(arg1, arg2);
+TemporalHelpers.assertPlainDate(result, 1, 1, "M01", 1, "date result", "ce", 1);
+assert.sameValue(result.getISOFields().calendar, "gregory", "calendar slot should store a string");
+assert.compareArray(actual, expected, "order of operations");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateFromFields/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/argument-infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/argument-infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..5f8b431d70
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/argument-infinity-throws-rangeerror.js
@@ -0,0 +1,32 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if any value in a property bag for either argument is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.dateuntil
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const other = new Temporal.PlainDate(2001, 6, 3);
+const base = { era: "ad", month: 5, day: 2, calendar: instance };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.dateUntil({ ...base, eraYear: inf }, other), `eraYear property cannot be ${inf}`);
+
+  assert.throws(RangeError, () => instance.dateUntil(other, { ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls1 = [];
+  const obj1 = TemporalHelpers.toPrimitiveObserver(calls1, inf, "eraYear");
+  assert.throws(RangeError, () => instance.dateUntil({ ...base, eraYear: obj1 }, other));
+  assert.compareArray(calls1, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+
+  const calls2 = [];
+  const obj2 = TemporalHelpers.toPrimitiveObserver(calls2, inf, "eraYear");
+  assert.throws(RangeError, () => instance.dateUntil(other, { ...base, eraYear: obj2 }));
+  assert.compareArray(calls2, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/until-across-lunisolar-leap-months.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/until-across-lunisolar-leap-months.js
new file mode 100644
index 0000000000..4114320ba6
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/until-across-lunisolar-leap-months.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: dateUntil works as expected after a leap month in a lunisolar calendar
+esid: sec-temporal.calendar.prototype.dateuntil
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("chinese");
+
+// 2001 is a leap year in the Chinese calendar with a M04L leap month.
+// Therefore, month: 6 is M05 in 2001 but M06 in 2000 which is not a leap year.
+const one = Temporal.PlainDate.from({ year: 2000, month: 6, day: 1, calendar: 'chinese' });
+const two = Temporal.PlainDate.from({ year: 2001, month: 6, day: 1, calendar: 'chinese' });
+
+const expected = { years: 'P12M', months: 'P12M', weeks: 'P50W4D', days: 'P354D' };
+
+Object.entries(expected).forEach(([largestUnit, expectedResult]) => {
+  const actualResult = instance.dateUntil(one, two, { largestUnit });
+  assert.sameValue(actualResult.toString(), expectedResult);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/zero-length-duration-result.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/zero-length-duration-result.js
new file mode 100644
index 0000000000..b4aa45e979
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dateUntil/zero-length-duration-result.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: The duration from a date to itself is a zero duration (PT0S)
+esid: sec-temporal.calendar.prototype.dateuntil
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const date = new Temporal.PlainDate(2001, 6, 3);
+
+['year', 'month', 'week', 'day'].forEach((largestUnit) => {
+  const result = instance.dateUntil(date, date, { largestUnit });
+  assert.sameValue(result.toString(), 'PT0S');
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/day/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/day/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/day/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/day/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/day/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..fdbf3263a7
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/day/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.day
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.day({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.day({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/day/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/day/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/day/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfWeek/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfWeek/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfWeek/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfWeek/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfWeek/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..a539d386ad
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfWeek/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.dayofweek
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.dayOfWeek({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.dayOfWeek({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfWeek/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfWeek/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfWeek/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfYear/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfYear/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfYear/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfYear/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfYear/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..55e62fb72b
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfYear/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.dayofyear
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.dayOfYear({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.dayOfYear({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfYear/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfYear/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/dayOfYear/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInMonth/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInMonth/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInMonth/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInMonth/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInMonth/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..91fdf547f3
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInMonth/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.daysinmonth
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.daysInMonth({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.daysInMonth({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInMonth/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInMonth/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInMonth/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInWeek/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInWeek/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInWeek/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInWeek/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInWeek/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..d3e78fde8e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInWeek/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.daysinweek
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.daysInWeek({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.daysInWeek({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInWeek/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInWeek/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInWeek/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInYear/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInYear/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInYear/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInYear/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInYear/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..7d5dae7441
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInYear/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.daysinyear
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.daysInYear({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.daysInYear({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInYear/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInYear/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/daysInYear/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-builtin-calendar-no-array-iteration.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-builtin-calendar-no-array-iteration.js
new file mode 100644
index 0000000000..91f3b5cf63
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-builtin-calendar-no-array-iteration.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: >
+  Calling the method with a property bag argument with a builtin calendar causes
+  no observable array iteration when getting the calendar fields.
+features: [Temporal]
+---*/
+
+const arrayPrototypeSymbolIteratorOriginal = Array.prototype[Symbol.iterator];
+Array.prototype[Symbol.iterator] = function arrayIterator() {
+  throw new Test262Error("Array should not be iterated");
+}
+
+const instance = new Temporal.Calendar("iso8601");
+const arg = { year: 2000, month: 5, day: 2, calendar: "iso8601" };
+instance.era(arg);
+
+Array.prototype[Symbol.iterator] = arrayPrototypeSymbolIteratorOriginal;
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-calendar-datefromfields-called-with-null-prototype-fields.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-calendar-datefromfields-called-with-null-prototype-fields.js
new file mode 100644
index 0000000000..43ebecc229
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-calendar-datefromfields-called-with-null-prototype-fields.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: >
+    Calendar.dateFromFields method is called with a null-prototype fields object
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const calendar = TemporalHelpers.calendarCheckFieldsPrototypePollution();
+const instance = new Temporal.Calendar("iso8601");
+const arg = { year: 2000, month: 5, day: 2, calendar };
+instance.era(arg);
+assert.sameValue(calendar.dateFromFieldsCallCount, 1, "dateFromFields should be called on the property bag's calendar");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-constructor-in-calendar-fields.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-constructor-in-calendar-fields.js
new file mode 100644
index 0000000000..66df73d80e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-constructor-in-calendar-fields.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: If a calendar's fields() method returns a field named 'constructor', PrepareTemporalFields should throw a RangeError.
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const calendar = TemporalHelpers.calendarWithExtraFields(['constructor']);
+const arg = {year: 2023, month: 5, monthCode: 'M05', day: 1, calendar: calendar};
+const instance = new Temporal.Calendar("iso8601");
+
+assert.throws(RangeError, () => instance.era(arg));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-duplicate-calendar-fields.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-duplicate-calendar-fields.js
new file mode 100644
index 0000000000..39f2c7a757
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-duplicate-calendar-fields.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: If a calendar's fields() method returns duplicate field names, PrepareTemporalFields should throw a RangeError.
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+for (const extra_fields of [['foo', 'foo'], ['day'], ['month'], ['monthCode'], ['year']]) {
+    const calendar = TemporalHelpers.calendarWithExtraFields(extra_fields);
+    const arg = { year: 2023, month: 5, monthCode: 'M05', day: 1, calendar: calendar };
+    const instance = new Temporal.Calendar("iso8601");
+
+    assert.throws(RangeError, () => instance.era(arg));
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-leap-second.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-leap-second.js
new file mode 100644
index 0000000000..eeae48c412
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-leap-second.js
@@ -0,0 +1,29 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Leap second is a valid ISO string for PlainDate
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+let arg = "2016-12-31T23:59:60";
+const result1 = instance.era(arg);
+assert.sameValue(
+  result1,
+  undefined,
+  "leap second is a valid ISO string for PlainDate"
+);
+
+arg = { year: 2016, month: 12, day: 31, hour: 23, minute: 59, second: 60 };
+const result2 = instance.era(arg);
+assert.sameValue(
+  result2,
+  undefined,
+  "second: 60 is ignored in property bag for PlainDate"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-number.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-number.js
new file mode 100644
index 0000000000..a464d71968
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-number.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: A number cannot be used in place of a Temporal.PlainDate
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const numbers = [
+  1,
+  19761118,
+  -19761118,
+  1234567890,
+];
+
+for (const arg of numbers) {
+  assert.throws(
+    TypeError,
+    () => instance.era(arg),
+    'Numbers cannot be used in place of an ISO string for PlainDate'
+  );
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-case-insensitive.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-case-insensitive.js
new file mode 100644
index 0000000000..5ef11cb688
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-case-insensitive.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: The calendar name is case-insensitive
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const calendar = "IsO8601";
+
+const arg = { year: 1976, monthCode: "M11", day: 18, calendar };
+const result = instance.era(arg);
+assert.sameValue(result, undefined, "Calendar is case-insensitive");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-leap-second.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-leap-second.js
new file mode 100644
index 0000000000..e4a7ea689f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-leap-second.js
@@ -0,0 +1,23 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Leap second is a valid ISO string for a calendar in a property bag
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const calendar = "2016-12-31T23:59:60";
+
+const arg = { year: 1976, monthCode: "M11", day: 18, calendar };
+const result = instance.era(arg);
+assert.sameValue(
+  result,
+  undefined,
+  "leap second is a valid ISO string for calendar"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-number.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-number.js
new file mode 100644
index 0000000000..aaebffa0a5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-number.js
@@ -0,0 +1,29 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: A number as calendar in a property bag is not accepted
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const numbers = [
+  1,
+  19970327,
+  -19970327,
+  1234567890,
+];
+
+for (const calendar of numbers) {
+  const arg = { year: 1976, monthCode: "M11", day: 18, calendar };
+  assert.throws(
+    TypeError,
+    () => instance.era(arg),
+    "Numbers cannot be used as a calendar"
+  );
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-string.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-string.js
new file mode 100644
index 0000000000..12a89fcfe6
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-string.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: A calendar ID is valid input for Calendar
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const calendar = "iso8601";
+
+const arg = { year: 1976, monthCode: "M11", day: 18, calendar };
+const result = instance.era(arg);
+assert.sameValue(result, undefined, `Calendar created from string "${calendar}"`);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-wrong-type.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-wrong-type.js
new file mode 100644
index 0000000000..1c39744a16
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-wrong-type.js
@@ -0,0 +1,46 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: >
+  Appropriate error thrown when a calendar property from a property bag cannot
+  be converted to a calendar object or string
+features: [BigInt, Symbol, Temporal]
+---*/
+
+const timeZone = new Temporal.TimeZone("UTC");
+const instance = new Temporal.Calendar("iso8601");
+
+const primitiveTests = [
+  [null, "null"],
+  [true, "boolean"],
+  ["", "empty string"],
+  [1, "number that doesn't convert to a valid ISO string"],
+  [1n, "bigint"],
+];
+
+for (const [calendar, description] of primitiveTests) {
+  const arg = { year: 2019, monthCode: "M11", day: 1, calendar };
+  assert.throws(
+    typeof calendar === 'string' ? RangeError : TypeError,
+    () => instance.era(arg),
+    `${description} does not convert to a valid ISO string`
+  );
+}
+
+const typeErrorTests = [
+  [Symbol(), "symbol"],
+  [{}, "plain object that doesn't implement the protocol"],
+  [new Temporal.TimeZone("UTC"), "time zone instance"],
+  [Temporal.Calendar, "Temporal.Calendar, object"],
+  [Temporal.Calendar.prototype, "Temporal.Calendar.prototype, object"],  // fails brand check in dateFromFields()
+];
+
+for (const [calendar, description] of typeErrorTests) {
+  const arg = { year: 2019, monthCode: "M11", day: 1, calendar };
+  assert.throws(TypeError, () => instance.era(arg), `${description} is not a valid property bag and does not convert to a string`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-year-zero.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-year-zero.js
new file mode 100644
index 0000000000..d0698c070c
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-propertybag-calendar-year-zero.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Negative zero, as an extended year, is rejected
+features: [Temporal, arrow-function]
+---*/
+
+const invalidStrings = [
+  "-000000-10-31",
+  "-000000-10-31T17:45",
+  "-000000-10-31T17:45Z",
+  "-000000-10-31T17:45+01:00",
+  "-000000-10-31T17:45+00:00[UTC]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.era(arg),
+    "reject minus zero as extended year"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-proto-in-calendar-fields.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-proto-in-calendar-fields.js
new file mode 100644
index 0000000000..69c004192b
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-proto-in-calendar-fields.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: If a calendar's fields() method returns a field named '__proto__', PrepareTemporalFields should throw a RangeError.
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const calendar = TemporalHelpers.calendarWithExtraFields(['__proto__']);
+const arg = {year: 2023, month: 5, monthCode: 'M05', day: 1, calendar: calendar};
+const instance = new Temporal.Calendar("iso8601");
+
+assert.throws(RangeError, () => instance.era(arg));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-calendar-annotation.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-calendar-annotation.js
new file mode 100644
index 0000000000..0d537e511d
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-calendar-annotation.js
@@ -0,0 +1,33 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Various forms of calendar annotation; critical flag has no effect
+features: [Temporal]
+---*/
+
+const tests = [
+  ["2000-05-02[u-ca=iso8601]", "without time or time zone"],
+  ["2000-05-02[UTC][u-ca=iso8601]", "with time zone and no time"],
+  ["2000-05-02T15:23[u-ca=iso8601]", "without time zone"],
+  ["2000-05-02T15:23[UTC][u-ca=iso8601]", "with time zone"],
+  ["2000-05-02T15:23[!u-ca=iso8601]", "with ! and no time zone"],
+  ["2000-05-02T15:23[UTC][!u-ca=iso8601]", "with ! and time zone"],
+  ["2000-05-02T15:23[u-ca=iso8601][u-ca=discord]", "second annotation ignored"],
+];
+
+const instance = new Temporal.Calendar("iso8601");
+
+tests.forEach(([arg, description]) => {
+  const result = instance.era(arg);
+
+  assert.sameValue(
+    result,
+    undefined,
+    `calendar annotation (${description})`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-critical-unknown-annotation.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-critical-unknown-annotation.js
new file mode 100644
index 0000000000..5b4a441d16
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-critical-unknown-annotation.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Unknown annotations with critical flag are rejected
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1970-01-01[!foo=bar]",
+  "1970-01-01T00:00[!foo=bar]",
+  "1970-01-01T00:00[UTC][!foo=bar]",
+  "1970-01-01T00:00[u-ca=iso8601][!foo=bar]",
+  "1970-01-01T00:00[UTC][!foo=bar][u-ca=iso8601]",
+  "1970-01-01T00:00[foo=bar][!_foo-bar0=Dont-Ignore-This-99999999999]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.era(arg),
+    `reject unknown annotation with critical flag: ${arg}`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-date-with-utc-offset.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-date-with-utc-offset.js
new file mode 100644
index 0000000000..c425dea4db
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-date-with-utc-offset.js
@@ -0,0 +1,48 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: UTC offset not valid with format that does not include a time
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const validStrings = [
+  "2000-05-02T00+00:00",
+  "2000-05-02T00+00:00[UTC]",
+  "2000-05-02T00+00:00[!UTC]",
+  "2000-05-02T00-02:30[America/St_Johns]",
+];
+
+for (const arg of validStrings) {
+  const result = instance.era(arg);
+
+  assert.sameValue(
+    result,
+    undefined,
+    `"${arg}" is a valid UTC offset with time for PlainDate`
+  );
+}
+
+const invalidStrings = [
+  "2022-09-15Z",
+  "2022-09-15Z[UTC]",
+  "2022-09-15Z[Europe/Vienna]",
+  "2022-09-15+00:00",
+  "2022-09-15+00:00[UTC]",
+  "2022-09-15-02:30",
+  "2022-09-15-02:30[America/St_Johns]",
+];
+
+for (const arg of invalidStrings) {
+  assert.throws(
+    RangeError,
+    () => instance.era(arg),
+    `"${arg}" UTC offset without time is not valid for PlainDate`
+  );
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-invalid.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-invalid.js
new file mode 100644
index 0000000000..b1e77d48a6
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-invalid.js
@@ -0,0 +1,64 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: >
+  RangeError thrown if an invalid ISO string (or syntactically valid ISO string
+  that is not supported) is used as a PlainDate
+features: [Temporal, arrow-function]
+---*/
+
+const invalidStrings = [
+  // invalid ISO strings:
+  "",
+  "invalid iso8601",
+  "2020-01-00",
+  "2020-01-32",
+  "2020-02-30",
+  "2021-02-29",
+  "2020-00-01",
+  "2020-13-01",
+  "2020-01-01T",
+  "2020-01-01T25:00:00",
+  "2020-01-01T01:60:00",
+  "2020-01-01T01:60:61",
+  "2020-01-01junk",
+  "2020-01-01T00:00:00junk",
+  "2020-01-01T00:00:00+00:00junk",
+  "2020-01-01T00:00:00+00:00[UTC]junk",
+  "2020-01-01T00:00:00+00:00[UTC][u-ca=iso8601]junk",
+  "02020-01-01",
+  "2020-001-01",
+  "2020-01-001",
+  "2020-01-01T001",
+  "2020-01-01T01:001",
+  "2020-01-01T01:01:001",
+  // valid, but forms not supported in Temporal:
+  "2020-W01-1",
+  "2020-001",
+  "+0002020-01-01",
+  // valid, but this calendar must not exist:
+  "2020-01-01[u-ca=notexist]",
+  // may be valid in other contexts, but insufficient information for PlainDate:
+  "2020-01",
+  "+002020-01",
+  "01-01",
+  "2020-W01",
+  "P1Y",
+  "-P12Y",
+  // valid, but outside the supported range:
+  "-999999-01-01",
+  "+999999-01-01",
+];
+const instance = new Temporal.Calendar("iso8601");
+for (const arg of invalidStrings) {
+  assert.throws(
+    RangeError,
+    () => instance.era(arg),
+    `"${arg}" should not be a valid ISO string for a PlainDate`
+  );
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-multiple-calendar.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-multiple-calendar.js
new file mode 100644
index 0000000000..ab38062b05
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-multiple-calendar.js
@@ -0,0 +1,32 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: >
+  More than one calendar annotation is not syntactical if any have the criical
+  flag
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1970-01-01[u-ca=iso8601][!u-ca=iso8601]",
+  "1970-01-01[!u-ca=iso8601][u-ca=iso8601]",
+  "1970-01-01[UTC][u-ca=iso8601][!u-ca=iso8601]",
+  "1970-01-01[u-ca=iso8601][foo=bar][!u-ca=iso8601]",
+  "1970-01-01T00:00[u-ca=iso8601][!u-ca=iso8601]",
+  "1970-01-01T00:00[!u-ca=iso8601][u-ca=iso8601]",
+  "1970-01-01T00:00[UTC][u-ca=iso8601][!u-ca=iso8601]",
+  "1970-01-01T00:00[u-ca=iso8601][foo=bar][!u-ca=iso8601]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.era(arg),
+    `reject more than one calendar annotation if any critical: ${arg}`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-multiple-time-zone.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-multiple-time-zone.js
new file mode 100644
index 0000000000..52d1445216
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-multiple-time-zone.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: More than one time zone annotation is not syntactical
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1970-01-01[UTC][UTC]",
+  "1970-01-01T00:00[UTC][UTC]",
+  "1970-01-01T00:00[!UTC][UTC]",
+  "1970-01-01T00:00[UTC][!UTC]",
+  "1970-01-01T00:00[UTC][u-ca=iso8601][UTC]",
+  "1970-01-01T00:00[UTC][foo=bar][UTC]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.era(arg),
+    `reject more than one time zone annotation: ${arg}`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-time-separators.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-time-separators.js
new file mode 100644
index 0000000000..e3d6e7b62f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-time-separators.js
@@ -0,0 +1,29 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Time separator in string argument can vary
+features: [Temporal]
+---*/
+
+const tests = [
+  ["2000-05-02T15:23", "uppercase T"],
+  ["2000-05-02t15:23", "lowercase T"],
+  ["2000-05-02 15:23", "space between date and time"],
+];
+
+const instance = new Temporal.Calendar("iso8601");
+
+tests.forEach(([arg, description]) => {
+  const result = instance.era(arg);
+
+  assert.sameValue(
+    result,
+    undefined,
+    `variant time separators (${description})`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-time-zone-annotation.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-time-zone-annotation.js
new file mode 100644
index 0000000000..b6b41355b1
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-time-zone-annotation.js
@@ -0,0 +1,38 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Various forms of time zone annotation; critical flag has no effect
+features: [Temporal]
+---*/
+
+const tests = [
+  ["2000-05-02[Asia/Kolkata]", "named, with no time"],
+  ["2000-05-02[!Europe/Vienna]", "named, with ! and no time"],
+  ["2000-05-02[+00:00]", "numeric, with no time"],
+  ["2000-05-02[!-02:30]", "numeric, with ! and no time"],
+  ["2000-05-02T15:23[America/Sao_Paulo]", "named, with no offset"],
+  ["2000-05-02T15:23[!Asia/Tokyo]", "named, with ! and no offset"],
+  ["2000-05-02T15:23[-02:30]", "numeric, with no offset"],
+  ["2000-05-02T15:23[!+00:00]", "numeric, with ! and no offset"],
+  ["2000-05-02T15:23+00:00[America/New_York]", "named, with offset"],
+  ["2000-05-02T15:23+00:00[!UTC]", "named, with offset and !"],
+  ["2000-05-02T15:23+00:00[+01:00]", "numeric, with offset"],
+  ["2000-05-02T15:23+00:00[!-08:00]", "numeric, with offset and !"],
+];
+
+const instance = new Temporal.Calendar("iso8601");
+
+tests.forEach(([arg, description]) => {
+  const result = instance.era(arg);
+
+  assert.sameValue(
+    result,
+    undefined,
+    `time zone annotation (${description})`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-unknown-annotation.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-unknown-annotation.js
new file mode 100644
index 0000000000..5949984435
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-unknown-annotation.js
@@ -0,0 +1,32 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Various forms of unknown annotation
+features: [Temporal]
+---*/
+
+const tests = [
+  ["2000-05-02[foo=bar]", "without time"],
+  ["2000-05-02T15:23[foo=bar]", "alone"],
+  ["2000-05-02T15:23[UTC][foo=bar]", "with time zone"],
+  ["2000-05-02T15:23[u-ca=iso8601][foo=bar]", "with calendar"],
+  ["2000-05-02T15:23[UTC][foo=bar][u-ca=iso8601]", "with time zone and calendar"],
+  ["2000-05-02T15:23[foo=bar][_foo-bar0=Ignore-This-999999999999]", "with another unknown annotation"],
+];
+
+const instance = new Temporal.Calendar("iso8601");
+
+tests.forEach(([arg, description]) => {
+  const result = instance.era(arg);
+
+  assert.sameValue(
+    result,
+    undefined,
+    `unknown annotation (${description})`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-with-utc-designator.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-with-utc-designator.js
new file mode 100644
index 0000000000..467398e21b
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-string-with-utc-designator.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: RangeError thrown if a string with UTC designator is used as a PlainDate
+features: [Temporal, arrow-function]
+---*/
+
+const invalidStrings = [
+  "2019-10-01T09:00:00Z",
+  "2019-10-01T09:00:00Z[UTC]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.era(arg),
+    "String with UTC designator should not be valid as a PlainDate"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-wrong-type.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-wrong-type.js
new file mode 100644
index 0000000000..660bf41a47
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-wrong-type.js
@@ -0,0 +1,43 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: >
+  Appropriate error thrown when argument cannot be converted to a valid string
+  or property bag for PlainDate
+features: [BigInt, Symbol, Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const primitiveTests = [
+  [undefined, "undefined"],
+  [null, "null"],
+  [true, "boolean"],
+  ["", "empty string"],
+  [1, "number that doesn't convert to a valid ISO string"],
+  [1n, "bigint"],
+];
+
+for (const [arg, description] of primitiveTests) {
+  assert.throws(
+    typeof arg === 'string' ? RangeError : TypeError,
+    () => instance.era(arg),
+    `${description} does not convert to a valid ISO string`
+  );
+}
+
+const typeErrorTests = [
+  [Symbol(), "symbol"],
+  [{}, "plain object"],
+  [Temporal.PlainDate, "Temporal.PlainDate, object"],
+  [Temporal.PlainDate.prototype, "Temporal.PlainDate.prototype, object"],
+];
+
+for (const [arg, description] of typeErrorTests) {
+  assert.throws(TypeError, () => instance.era(arg), `${description} is not a valid property bag and does not convert to a string`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-convert.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-convert.js
new file mode 100644
index 0000000000..62a046358e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-convert.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: An exception from TimeZone#getOffsetNanosecondsFor() is propagated.
+features: [Temporal]
+---*/
+
+class TZ extends Temporal.TimeZone {
+  constructor() { super("UTC") }
+  getOffsetNanosecondsFor() { throw new Test262Error() }
+}
+
+const tz = new TZ();
+const arg = new Temporal.ZonedDateTime(0n, tz);
+const instance = new Temporal.Calendar("iso8601");
+
+assert.throws(Test262Error, () => instance.era(arg));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-slots.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-slots.js
new file mode 100644
index 0000000000..f7958d0d92
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-slots.js
@@ -0,0 +1,40 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Getters are not called when converting a ZonedDateTime to a PlainDate.
+includes: [compareArray.js]
+features: [Temporal]
+---*/
+
+const actual = [];
+const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.ZonedDateTime.prototype);
+const getters = ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond", "calendar"];
+
+for (const property of getters) {
+  Object.defineProperty(Temporal.ZonedDateTime.prototype, property, {
+    get() {
+      actual.push(`get ${property}`);
+      const value = prototypeDescrs[property].get.call(this);
+      return {
+        toString() {
+          actual.push(`toString ${property}`);
+          return value.toString();
+        },
+        valueOf() {
+          actual.push(`valueOf ${property}`);
+          return value;
+        },
+      };
+    },
+  });
+}
+
+const arg = new Temporal.ZonedDateTime(0n, "UTC");
+const instance = new Temporal.Calendar("iso8601");
+instance.era(arg);
+assert.compareArray(actual, []);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-non-integer.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-non-integer.js
new file mode 100644
index 0000000000..1c31fe0571
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-non-integer.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: RangeError thrown if time zone reports an offset that is not an integer number of nanoseconds
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[3600_000_000_000.5, NaN, -Infinity, Infinity].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const calendar = new Temporal.Calendar("iso8601");
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(RangeError, () => calendar.era(datetime));
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-not-callable.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-not-callable.js
new file mode 100644
index 0000000000..8b97cf8f65
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-not-callable.js
@@ -0,0 +1,23 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable
+features: [BigInt, Symbol, Temporal, arrow-function]
+---*/
+
+[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach((notCallable) => {
+  const timeZone = new Temporal.TimeZone("UTC");
+  const calendar = new Temporal.Calendar("iso8601");
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  timeZone.getOffsetNanosecondsFor = notCallable;
+  assert.throws(
+    TypeError,
+    () => calendar.era(datetime),
+    `Uncallable ${notCallable === null ? 'null' : typeof notCallable} getOffsetNanosecondsFor should throw TypeError`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-out-of-range.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-out-of-range.js
new file mode 100644
index 0000000000..1ee0615f18
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-out-of-range.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: RangeError thrown if time zone reports an offset that is out of range
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[-86400_000_000_000, 86400_000_000_000].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const calendar = new Temporal.Calendar("iso8601");
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(RangeError, () => calendar.era(datetime));
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-wrong-type.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-wrong-type.js
new file mode 100644
index 0000000000..be7985d3ef
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-wrong-type.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: TypeError thrown if time zone reports an offset that is not a Number
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[
+  undefined,
+  null,
+  true,
+  "+01:00",
+  Symbol(),
+  3600_000_000_000n,
+  {},
+  { valueOf() { return 3600_000_000_000; } },
+].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const calendar = new Temporal.Calendar("iso8601");
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(TypeError, () => calendar.era(datetime));
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/branding.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/branding.js
new file mode 100644
index 0000000000..f2ae214643
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/branding.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Throw a TypeError if the receiver is invalid
+features: [Symbol, Temporal]
+---*/
+
+const era = Temporal.Calendar.prototype.era;
+
+assert.sameValue(typeof era, "function");
+
+assert.throws(TypeError, () => era.call(undefined), "undefined");
+assert.throws(TypeError, () => era.call(null), "null");
+assert.throws(TypeError, () => era.call(true), "true");
+assert.throws(TypeError, () => era.call(""), "empty string");
+assert.throws(TypeError, () => era.call(Symbol()), "symbol");
+assert.throws(TypeError, () => era.call(1), "1");
+assert.throws(TypeError, () => era.call({}), "plain object");
+assert.throws(TypeError, () => era.call(Temporal.Calendar), "Temporal.Calendar");
+assert.throws(TypeError, () => era.call(Temporal.Calendar.prototype), "Temporal.Calendar.prototype");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/builtin.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/builtin.js
new file mode 100644
index 0000000000..4a5da3447f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/builtin.js
@@ -0,0 +1,36 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: >
+    Tests that Temporal.Calendar.prototype.era
+    meets the requirements for built-in objects defined by the
+    introduction of chapter 17 of the ECMAScript Language Specification.
+info: |
+    Built-in functions that are not constructors do not have a "prototype" property unless
+    otherwise specified in the description of a particular function.
+
+    Unless specified otherwise, a built-in object that is callable as a function is a built-in
+    function object with the characteristics described in 10.3. Unless specified otherwise, the
+    [[Extensible]] internal slot of a built-in object initially has the value true.
+
+    Unless otherwise specified every built-in function and every built-in constructor has the
+    Function prototype object [...] as the value of its [[Prototype]] internal slot.
+features: [Temporal]
+---*/
+
+assert.sameValue(Object.isExtensible(Temporal.Calendar.prototype.era),
+  true, "Built-in objects must be extensible.");
+
+assert.sameValue(Object.prototype.toString.call(Temporal.Calendar.prototype.era),
+  "[object Function]", "Object.prototype.toString");
+
+assert.sameValue(Object.getPrototypeOf(Temporal.Calendar.prototype.era),
+  Function.prototype, "prototype");
+
+assert.sameValue(Temporal.Calendar.prototype.era.hasOwnProperty("prototype"),
+  false, "prototype property");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/calendar-datefromfields-called-with-options-undefined.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/calendar-datefromfields-called-with-options-undefined.js
new file mode 100644
index 0000000000..9337ec6781
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/calendar-datefromfields-called-with-options-undefined.js
@@ -0,0 +1,18 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: >
+    Calendar.dateFromFields method is called with undefined as the options value
+    when call originates internally
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const calendar = TemporalHelpers.calendarFromFieldsUndefinedOptions();
+calendar.era({ year: 2000, month: 5, day: 3, calendar });
+assert.sameValue(calendar.dateFromFieldsCallCount, 1);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..361c40927e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.era
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.era({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.era({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/length.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/length.js
new file mode 100644
index 0000000000..60121001e1
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/length.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Temporal.Calendar.prototype.era.length is 1
+info: |
+    Every built-in function object, including constructors, has a "length" property whose value is
+    an integer. Unless otherwise specified, this value is equal to the largest number of named
+    arguments shown in the subclause headings for the function description. Optional parameters
+    (which are indicated with brackets: [ ]) or rest parameters (which are shown using the form
+    «...name») are not included in the default argument count.
+
+    Unless otherwise specified, the "length" property of a built-in function object has the
+    attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.
+includes: [propertyHelper.js]
+features: [Temporal]
+---*/
+
+verifyProperty(Temporal.Calendar.prototype.era, "length", {
+  value: 1,
+  writable: false,
+  enumerable: false,
+  configurable: true,
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/name.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/name.js
new file mode 100644
index 0000000000..3f4180f251
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/name.js
@@ -0,0 +1,26 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Temporal.Calendar.prototype.era.name is "era".
+info: |
+    Every built-in function object, including constructors, that is not identified as an anonymous
+    function has a "name" property whose value is a String. Unless otherwise specified, this value
+    is the name that is given to the function in this specification.
+
+    Unless otherwise specified, the "name" property of a built-in function object, if it exists,
+    has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.
+includes: [propertyHelper.js]
+features: [Temporal]
+---*/
+
+verifyProperty(Temporal.Calendar.prototype.era, "name", {
+  value: "era",
+  writable: false,
+  enumerable: false,
+  configurable: true,
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/not-a-constructor.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/not-a-constructor.js
new file mode 100644
index 0000000000..04a80c93be
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/not-a-constructor.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: >
+  Temporal.Calendar.prototype.era does not implement [[Construct]], is not new-able
+info: |
+    Built-in function objects that are not identified as constructors do not implement the
+    [[Construct]] internal method unless otherwise specified in the description of a particular
+    function.
+includes: [isConstructor.js]
+features: [Reflect.construct, Temporal]
+---*/
+
+assert.throws(TypeError, () => {
+  new Temporal.Calendar.prototype.era();
+}, "Calling as constructor");
+
+assert.sameValue(isConstructor(Temporal.Calendar.prototype.era), false,
+  "isConstructor(Temporal.Calendar.prototype.era)");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/prop-desc.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/prop-desc.js
new file mode 100644
index 0000000000..e60bda1539
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/prop-desc.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: The "era" property of Temporal.Calendar.prototype
+includes: [propertyHelper.js]
+features: [Temporal]
+---*/
+
+assert.sameValue(
+  typeof Temporal.Calendar.prototype.era,
+  "function",
+  "`typeof Calendar.prototype.era` is `function`"
+);
+
+verifyProperty(Temporal.Calendar.prototype, "era", {
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/shell.js
new file mode 100644
index 0000000000..32df7c4217
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/shell.js
@@ -0,0 +1,2182 @@
+// GENERATED, DO NOT EDIT
+// file: isConstructor.js
+// Copyright (C) 2017 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: |
+    Test if a given function is a constructor function.
+defines: [isConstructor]
+features: [Reflect.construct]
+---*/
+
+function isConstructor(f) {
+    if (typeof f !== "function") {
+      throw new Test262Error("isConstructor invoked with a non-function value");
+    }
+
+    try {
+        Reflect.construct(function(){}, [], f);
+    } catch (e) {
+        return false;
+    }
+    return true;
+}
+
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/year-zero.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/year-zero.js
new file mode 100644
index 0000000000..1f9c6a9ca5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/era/year-zero.js
@@ -0,0 +1,26 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.era
+description: Negative zero, as an extended year, is rejected
+features: [Temporal, arrow-function]
+---*/
+
+const invalidStrings = [
+  "-000000-10-31",
+  "-000000-10-31T00:45",
+  "-000000-10-31T00:45+01:00",
+  "-000000-10-31T00:45+00:00[UTC]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.era(arg),
+    "reject minus zero as extended year"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-builtin-calendar-no-array-iteration.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-builtin-calendar-no-array-iteration.js
new file mode 100644
index 0000000000..a2b5a5afcf
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-builtin-calendar-no-array-iteration.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: >
+  Calling the method with a property bag argument with a builtin calendar causes
+  no observable array iteration when getting the calendar fields.
+features: [Temporal]
+---*/
+
+const arrayPrototypeSymbolIteratorOriginal = Array.prototype[Symbol.iterator];
+Array.prototype[Symbol.iterator] = function arrayIterator() {
+  throw new Test262Error("Array should not be iterated");
+}
+
+const instance = new Temporal.Calendar("iso8601");
+const arg = { year: 2000, month: 5, day: 2, calendar: "iso8601" };
+instance.eraYear(arg);
+
+Array.prototype[Symbol.iterator] = arrayPrototypeSymbolIteratorOriginal;
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-calendar-datefromfields-called-with-null-prototype-fields.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-calendar-datefromfields-called-with-null-prototype-fields.js
new file mode 100644
index 0000000000..5de9f82a13
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-calendar-datefromfields-called-with-null-prototype-fields.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: >
+    Calendar.dateFromFields method is called with a null-prototype fields object
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const calendar = TemporalHelpers.calendarCheckFieldsPrototypePollution();
+const instance = new Temporal.Calendar("iso8601");
+const arg = { year: 2000, month: 5, day: 2, calendar };
+instance.eraYear(arg);
+assert.sameValue(calendar.dateFromFieldsCallCount, 1, "dateFromFields should be called on the property bag's calendar");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-constructor-in-calendar-fields.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-constructor-in-calendar-fields.js
new file mode 100644
index 0000000000..525d21d4fc
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-constructor-in-calendar-fields.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: If a calendar's fields() method returns a field named 'constructor', PrepareTemporalFields should throw a RangeError.
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const calendar = TemporalHelpers.calendarWithExtraFields(['constructor']);
+const arg = {year: 2023, month: 5, monthCode: 'M05', day: 1, calendar: calendar};
+const instance = new Temporal.Calendar("iso8601");
+
+assert.throws(RangeError, () => instance.eraYear(arg));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-duplicate-calendar-fields.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-duplicate-calendar-fields.js
new file mode 100644
index 0000000000..243fb8de8a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-duplicate-calendar-fields.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: If a calendar's fields() method returns duplicate field names, PrepareTemporalFields should throw a RangeError.
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+for (const extra_fields of [['foo', 'foo'], ['day'], ['month'], ['monthCode'], ['year']]) {
+    const calendar = TemporalHelpers.calendarWithExtraFields(extra_fields);
+    const arg = { year: 2023, month: 5, monthCode: 'M05', day: 1, calendar: calendar };
+    const instance = new Temporal.Calendar("iso8601");
+
+    assert.throws(RangeError, () => instance.eraYear(arg));
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-leap-second.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-leap-second.js
new file mode 100644
index 0000000000..e0fa4fa9a5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-leap-second.js
@@ -0,0 +1,29 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Leap second is a valid ISO string for PlainDate
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+let arg = "2016-12-31T23:59:60";
+const result1 = instance.eraYear(arg);
+assert.sameValue(
+  result1,
+  undefined,
+  "leap second is a valid ISO string for PlainDate"
+);
+
+arg = { year: 2016, month: 12, day: 31, hour: 23, minute: 59, second: 60 };
+const result2 = instance.eraYear(arg);
+assert.sameValue(
+  result2,
+  undefined,
+  "second: 60 is ignored in property bag for PlainDate"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-number.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-number.js
new file mode 100644
index 0000000000..9417849c6a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-number.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: A number cannot be used in place of a Temporal.PlainDate
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const numbers = [
+  1,
+  19761118,
+  -19761118,
+  1234567890,
+];
+
+for (const arg of numbers) {
+  assert.throws(
+    TypeError,
+    () => instance.eraYear(arg),
+    'Numbers cannot be used in place of an ISO string for PlainDate'
+  );
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-case-insensitive.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-case-insensitive.js
new file mode 100644
index 0000000000..40e048aa59
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-case-insensitive.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: The calendar name is case-insensitive
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const calendar = "IsO8601";
+
+const arg = { year: 1976, monthCode: "M11", day: 18, calendar };
+const result = instance.eraYear(arg);
+assert.sameValue(result, undefined, "Calendar is case-insensitive");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-leap-second.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-leap-second.js
new file mode 100644
index 0000000000..845624b518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-leap-second.js
@@ -0,0 +1,23 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Leap second is a valid ISO string for a calendar in a property bag
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const calendar = "2016-12-31T23:59:60";
+
+const arg = { year: 1976, monthCode: "M11", day: 18, calendar };
+const result = instance.eraYear(arg);
+assert.sameValue(
+  result,
+  undefined,
+  "leap second is a valid ISO string for calendar"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-number.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-number.js
new file mode 100644
index 0000000000..e9d8fc746c
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-number.js
@@ -0,0 +1,29 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: A number as calendar in a property bag is not accepted
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const numbers = [
+  1,
+  19970327,
+  -19970327,
+  1234567890,
+];
+
+for (const calendar of numbers) {
+  const arg = { year: 1976, monthCode: "M11", day: 18, calendar };
+  assert.throws(
+    TypeError,
+    () => instance.eraYear(arg),
+    "Numbers cannot be used as a calendar"
+  );
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-string.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-string.js
new file mode 100644
index 0000000000..d40d3152a1
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-string.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: A calendar ID is valid input for Calendar
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const calendar = "iso8601";
+
+const arg = { year: 1976, monthCode: "M11", day: 18, calendar };
+const result = instance.eraYear(arg);
+assert.sameValue(result, undefined, `Calendar created from string "${calendar}"`);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-wrong-type.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-wrong-type.js
new file mode 100644
index 0000000000..5b75cd27e5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-wrong-type.js
@@ -0,0 +1,46 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: >
+  Appropriate error thrown when a calendar property from a property bag cannot
+  be converted to a calendar object or string
+features: [BigInt, Symbol, Temporal]
+---*/
+
+const timeZone = new Temporal.TimeZone("UTC");
+const instance = new Temporal.Calendar("iso8601");
+
+const primitiveTests = [
+  [null, "null"],
+  [true, "boolean"],
+  ["", "empty string"],
+  [1, "number that doesn't convert to a valid ISO string"],
+  [1n, "bigint"],
+];
+
+for (const [calendar, description] of primitiveTests) {
+  const arg = { year: 2019, monthCode: "M11", day: 1, calendar };
+  assert.throws(
+    typeof calendar === 'string' ? RangeError : TypeError,
+    () => instance.eraYear(arg),
+    `${description} does not convert to a valid ISO string`
+  );
+}
+
+const typeErrorTests = [
+  [Symbol(), "symbol"],
+  [{}, "plain object that doesn't implement the protocol"],
+  [new Temporal.TimeZone("UTC"), "time zone instance"],
+  [Temporal.Calendar, "Temporal.Calendar, object"],
+  [Temporal.Calendar.prototype, "Temporal.Calendar.prototype, object"],  // fails brand check in dateFromFields()
+];
+
+for (const [calendar, description] of typeErrorTests) {
+  const arg = { year: 2019, monthCode: "M11", day: 1, calendar };
+  assert.throws(TypeError, () => instance.eraYear(arg), `${description} is not a valid property bag and does not convert to a string`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-year-zero.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-year-zero.js
new file mode 100644
index 0000000000..65675a5894
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-propertybag-calendar-year-zero.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Negative zero, as an extended year, is rejected
+features: [Temporal, arrow-function]
+---*/
+
+const invalidStrings = [
+  "-000000-10-31",
+  "-000000-10-31T17:45",
+  "-000000-10-31T17:45Z",
+  "-000000-10-31T17:45+01:00",
+  "-000000-10-31T17:45+00:00[UTC]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.eraYear(arg),
+    "reject minus zero as extended year"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-proto-in-calendar-fields.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-proto-in-calendar-fields.js
new file mode 100644
index 0000000000..a664730c59
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-proto-in-calendar-fields.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: If a calendar's fields() method returns a field named '__proto__', PrepareTemporalFields should throw a RangeError.
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const calendar = TemporalHelpers.calendarWithExtraFields(['__proto__']);
+const arg = {year: 2023, month: 5, monthCode: 'M05', day: 1, calendar: calendar};
+const instance = new Temporal.Calendar("iso8601");
+
+assert.throws(RangeError, () => instance.eraYear(arg));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-calendar-annotation.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-calendar-annotation.js
new file mode 100644
index 0000000000..562c2fdee1
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-calendar-annotation.js
@@ -0,0 +1,33 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Various forms of calendar annotation; critical flag has no effect
+features: [Temporal]
+---*/
+
+const tests = [
+  ["2000-05-02[u-ca=iso8601]", "without time or time zone"],
+  ["2000-05-02[UTC][u-ca=iso8601]", "with time zone and no time"],
+  ["2000-05-02T15:23[u-ca=iso8601]", "without time zone"],
+  ["2000-05-02T15:23[UTC][u-ca=iso8601]", "with time zone"],
+  ["2000-05-02T15:23[!u-ca=iso8601]", "with ! and no time zone"],
+  ["2000-05-02T15:23[UTC][!u-ca=iso8601]", "with ! and time zone"],
+  ["2000-05-02T15:23[u-ca=iso8601][u-ca=discord]", "second annotation ignored"],
+];
+
+const instance = new Temporal.Calendar("iso8601");
+
+tests.forEach(([arg, description]) => {
+  const result = instance.eraYear(arg);
+
+  assert.sameValue(
+    result,
+    undefined,
+    `calendar annotation (${description})`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-critical-unknown-annotation.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-critical-unknown-annotation.js
new file mode 100644
index 0000000000..63419054b5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-critical-unknown-annotation.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Unknown annotations with critical flag are rejected
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1970-01-01[!foo=bar]",
+  "1970-01-01T00:00[!foo=bar]",
+  "1970-01-01T00:00[UTC][!foo=bar]",
+  "1970-01-01T00:00[u-ca=iso8601][!foo=bar]",
+  "1970-01-01T00:00[UTC][!foo=bar][u-ca=iso8601]",
+  "1970-01-01T00:00[foo=bar][!_foo-bar0=Dont-Ignore-This-99999999999]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.eraYear(arg),
+    `reject unknown annotation with critical flag: ${arg}`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-date-with-utc-offset.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-date-with-utc-offset.js
new file mode 100644
index 0000000000..0ad32ed291
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-date-with-utc-offset.js
@@ -0,0 +1,48 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: UTC offset not valid with format that does not include a time
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const validStrings = [
+  "2000-05-02T00+00:00",
+  "2000-05-02T00+00:00[UTC]",
+  "2000-05-02T00+00:00[!UTC]",
+  "2000-05-02T00-02:30[America/St_Johns]",
+];
+
+for (const arg of validStrings) {
+  const result = instance.eraYear(arg);
+
+  assert.sameValue(
+    result,
+    undefined,
+    `"${arg}" is a valid UTC offset with time for PlainDate`
+  );
+}
+
+const invalidStrings = [
+  "2022-09-15Z",
+  "2022-09-15Z[UTC]",
+  "2022-09-15Z[Europe/Vienna]",
+  "2022-09-15+00:00",
+  "2022-09-15+00:00[UTC]",
+  "2022-09-15-02:30",
+  "2022-09-15-02:30[America/St_Johns]",
+];
+
+for (const arg of invalidStrings) {
+  assert.throws(
+    RangeError,
+    () => instance.eraYear(arg),
+    `"${arg}" UTC offset without time is not valid for PlainDate`
+  );
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-invalid.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-invalid.js
new file mode 100644
index 0000000000..721a903b93
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-invalid.js
@@ -0,0 +1,64 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: >
+  RangeError thrown if an invalid ISO string (or syntactically valid ISO string
+  that is not supported) is used as a PlainDate
+features: [Temporal, arrow-function]
+---*/
+
+const invalidStrings = [
+  // invalid ISO strings:
+  "",
+  "invalid iso8601",
+  "2020-01-00",
+  "2020-01-32",
+  "2020-02-30",
+  "2021-02-29",
+  "2020-00-01",
+  "2020-13-01",
+  "2020-01-01T",
+  "2020-01-01T25:00:00",
+  "2020-01-01T01:60:00",
+  "2020-01-01T01:60:61",
+  "2020-01-01junk",
+  "2020-01-01T00:00:00junk",
+  "2020-01-01T00:00:00+00:00junk",
+  "2020-01-01T00:00:00+00:00[UTC]junk",
+  "2020-01-01T00:00:00+00:00[UTC][u-ca=iso8601]junk",
+  "02020-01-01",
+  "2020-001-01",
+  "2020-01-001",
+  "2020-01-01T001",
+  "2020-01-01T01:001",
+  "2020-01-01T01:01:001",
+  // valid, but forms not supported in Temporal:
+  "2020-W01-1",
+  "2020-001",
+  "+0002020-01-01",
+  // valid, but this calendar must not exist:
+  "2020-01-01[u-ca=notexist]",
+  // may be valid in other contexts, but insufficient information for PlainDate:
+  "2020-01",
+  "+002020-01",
+  "01-01",
+  "2020-W01",
+  "P1Y",
+  "-P12Y",
+  // valid, but outside the supported range:
+  "-999999-01-01",
+  "+999999-01-01",
+];
+const instance = new Temporal.Calendar("iso8601");
+for (const arg of invalidStrings) {
+  assert.throws(
+    RangeError,
+    () => instance.eraYear(arg),
+    `"${arg}" should not be a valid ISO string for a PlainDate`
+  );
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-multiple-calendar.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-multiple-calendar.js
new file mode 100644
index 0000000000..c72b51b846
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-multiple-calendar.js
@@ -0,0 +1,32 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: >
+  More than one calendar annotation is not syntactical if any have the criical
+  flag
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1970-01-01[u-ca=iso8601][!u-ca=iso8601]",
+  "1970-01-01[!u-ca=iso8601][u-ca=iso8601]",
+  "1970-01-01[UTC][u-ca=iso8601][!u-ca=iso8601]",
+  "1970-01-01[u-ca=iso8601][foo=bar][!u-ca=iso8601]",
+  "1970-01-01T00:00[u-ca=iso8601][!u-ca=iso8601]",
+  "1970-01-01T00:00[!u-ca=iso8601][u-ca=iso8601]",
+  "1970-01-01T00:00[UTC][u-ca=iso8601][!u-ca=iso8601]",
+  "1970-01-01T00:00[u-ca=iso8601][foo=bar][!u-ca=iso8601]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.eraYear(arg),
+    `reject more than one calendar annotation if any critical: ${arg}`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-multiple-time-zone.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-multiple-time-zone.js
new file mode 100644
index 0000000000..7f73fd08c7
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-multiple-time-zone.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: More than one time zone annotation is not syntactical
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1970-01-01[UTC][UTC]",
+  "1970-01-01T00:00[UTC][UTC]",
+  "1970-01-01T00:00[!UTC][UTC]",
+  "1970-01-01T00:00[UTC][!UTC]",
+  "1970-01-01T00:00[UTC][u-ca=iso8601][UTC]",
+  "1970-01-01T00:00[UTC][foo=bar][UTC]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.eraYear(arg),
+    `reject more than one time zone annotation: ${arg}`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-time-separators.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-time-separators.js
new file mode 100644
index 0000000000..df883826af
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-time-separators.js
@@ -0,0 +1,29 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Time separator in string argument can vary
+features: [Temporal]
+---*/
+
+const tests = [
+  ["2000-05-02T15:23", "uppercase T"],
+  ["2000-05-02t15:23", "lowercase T"],
+  ["2000-05-02 15:23", "space between date and time"],
+];
+
+const instance = new Temporal.Calendar("iso8601");
+
+tests.forEach(([arg, description]) => {
+  const result = instance.eraYear(arg);
+
+  assert.sameValue(
+    result,
+    undefined,
+    `variant time separators (${description})`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-time-zone-annotation.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-time-zone-annotation.js
new file mode 100644
index 0000000000..6a2cb0b7e5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-time-zone-annotation.js
@@ -0,0 +1,38 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Various forms of time zone annotation; critical flag has no effect
+features: [Temporal]
+---*/
+
+const tests = [
+  ["2000-05-02[Asia/Kolkata]", "named, with no time"],
+  ["2000-05-02[!Europe/Vienna]", "named, with ! and no time"],
+  ["2000-05-02[+00:00]", "numeric, with no time"],
+  ["2000-05-02[!-02:30]", "numeric, with ! and no time"],
+  ["2000-05-02T15:23[America/Sao_Paulo]", "named, with no offset"],
+  ["2000-05-02T15:23[!Asia/Tokyo]", "named, with ! and no offset"],
+  ["2000-05-02T15:23[-02:30]", "numeric, with no offset"],
+  ["2000-05-02T15:23[!+00:00]", "numeric, with ! and no offset"],
+  ["2000-05-02T15:23+00:00[America/New_York]", "named, with offset"],
+  ["2000-05-02T15:23+00:00[!UTC]", "named, with offset and !"],
+  ["2000-05-02T15:23+00:00[+01:00]", "numeric, with offset"],
+  ["2000-05-02T15:23+00:00[!-08:00]", "numeric, with offset and !"],
+];
+
+const instance = new Temporal.Calendar("iso8601");
+
+tests.forEach(([arg, description]) => {
+  const result = instance.eraYear(arg);
+
+  assert.sameValue(
+    result,
+    undefined,
+    `time zone annotation (${description})`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-unknown-annotation.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-unknown-annotation.js
new file mode 100644
index 0000000000..4540e6c7ca
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-unknown-annotation.js
@@ -0,0 +1,32 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Various forms of unknown annotation
+features: [Temporal]
+---*/
+
+const tests = [
+  ["2000-05-02[foo=bar]", "without time"],
+  ["2000-05-02T15:23[foo=bar]", "alone"],
+  ["2000-05-02T15:23[UTC][foo=bar]", "with time zone"],
+  ["2000-05-02T15:23[u-ca=iso8601][foo=bar]", "with calendar"],
+  ["2000-05-02T15:23[UTC][foo=bar][u-ca=iso8601]", "with time zone and calendar"],
+  ["2000-05-02T15:23[foo=bar][_foo-bar0=Ignore-This-999999999999]", "with another unknown annotation"],
+];
+
+const instance = new Temporal.Calendar("iso8601");
+
+tests.forEach(([arg, description]) => {
+  const result = instance.eraYear(arg);
+
+  assert.sameValue(
+    result,
+    undefined,
+    `unknown annotation (${description})`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-with-utc-designator.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-with-utc-designator.js
new file mode 100644
index 0000000000..378aa0e5d4
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-string-with-utc-designator.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: RangeError thrown if a string with UTC designator is used as a PlainDate
+features: [Temporal, arrow-function]
+---*/
+
+const invalidStrings = [
+  "2019-10-01T09:00:00Z",
+  "2019-10-01T09:00:00Z[UTC]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.eraYear(arg),
+    "String with UTC designator should not be valid as a PlainDate"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-wrong-type.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-wrong-type.js
new file mode 100644
index 0000000000..41af3fe618
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-wrong-type.js
@@ -0,0 +1,43 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: >
+  Appropriate error thrown when argument cannot be converted to a valid string
+  or property bag for PlainDate
+features: [BigInt, Symbol, Temporal]
+---*/
+
+const instance = new Temporal.Calendar("iso8601");
+
+const primitiveTests = [
+  [undefined, "undefined"],
+  [null, "null"],
+  [true, "boolean"],
+  ["", "empty string"],
+  [1, "number that doesn't convert to a valid ISO string"],
+  [1n, "bigint"],
+];
+
+for (const [arg, description] of primitiveTests) {
+  assert.throws(
+    typeof arg === 'string' ? RangeError : TypeError,
+    () => instance.eraYear(arg),
+    `${description} does not convert to a valid ISO string`
+  );
+}
+
+const typeErrorTests = [
+  [Symbol(), "symbol"],
+  [{}, "plain object"],
+  [Temporal.PlainDate, "Temporal.PlainDate, object"],
+  [Temporal.PlainDate.prototype, "Temporal.PlainDate.prototype, object"],
+];
+
+for (const [arg, description] of typeErrorTests) {
+  assert.throws(TypeError, () => instance.eraYear(arg), `${description} is not a valid property bag and does not convert to a string`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-convert.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-convert.js
new file mode 100644
index 0000000000..07abdb0eb7
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-convert.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: An exception from TimeZone#getOffsetNanosecondsFor() is propagated.
+features: [Temporal]
+---*/
+
+class TZ extends Temporal.TimeZone {
+  constructor() { super("UTC") }
+  getOffsetNanosecondsFor() { throw new Test262Error() }
+}
+
+const tz = new TZ();
+const arg = new Temporal.ZonedDateTime(0n, tz);
+const instance = new Temporal.Calendar("iso8601");
+
+assert.throws(Test262Error, () => instance.eraYear(arg));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-slots.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-slots.js
new file mode 100644
index 0000000000..94bef9152a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-slots.js
@@ -0,0 +1,40 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Getters are not called when converting a ZonedDateTime to a PlainDate.
+includes: [compareArray.js]
+features: [Temporal]
+---*/
+
+const actual = [];
+const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.ZonedDateTime.prototype);
+const getters = ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond", "calendar"];
+
+for (const property of getters) {
+  Object.defineProperty(Temporal.ZonedDateTime.prototype, property, {
+    get() {
+      actual.push(`get ${property}`);
+      const value = prototypeDescrs[property].get.call(this);
+      return {
+        toString() {
+          actual.push(`toString ${property}`);
+          return value.toString();
+        },
+        valueOf() {
+          actual.push(`valueOf ${property}`);
+          return value;
+        },
+      };
+    },
+  });
+}
+
+const arg = new Temporal.ZonedDateTime(0n, "UTC");
+const instance = new Temporal.Calendar("iso8601");
+instance.eraYear(arg);
+assert.compareArray(actual, []);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-non-integer.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-non-integer.js
new file mode 100644
index 0000000000..ee263584bd
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-non-integer.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: RangeError thrown if time zone reports an offset that is not an integer number of nanoseconds
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[3600_000_000_000.5, NaN, -Infinity, Infinity].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const calendar = new Temporal.Calendar("iso8601");
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(RangeError, () => calendar.eraYear(datetime));
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-not-callable.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-not-callable.js
new file mode 100644
index 0000000000..09ce6a6f72
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-not-callable.js
@@ -0,0 +1,23 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable
+features: [BigInt, Symbol, Temporal, arrow-function]
+---*/
+
+[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach((notCallable) => {
+  const timeZone = new Temporal.TimeZone("UTC");
+  const calendar = new Temporal.Calendar("iso8601");
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  timeZone.getOffsetNanosecondsFor = notCallable;
+  assert.throws(
+    TypeError,
+    () => calendar.eraYear(datetime),
+    `Uncallable ${notCallable === null ? 'null' : typeof notCallable} getOffsetNanosecondsFor should throw TypeError`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-out-of-range.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-out-of-range.js
new file mode 100644
index 0000000000..1ba9d767f4
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-out-of-range.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: RangeError thrown if time zone reports an offset that is out of range
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[-86400_000_000_000, 86400_000_000_000].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const calendar = new Temporal.Calendar("iso8601");
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(RangeError, () => calendar.eraYear(datetime));
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-wrong-type.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-wrong-type.js
new file mode 100644
index 0000000000..7341b73e02
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/argument-zoneddatetime-timezone-getoffsetnanosecondsfor-wrong-type.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: TypeError thrown if time zone reports an offset that is not a Number
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[
+  undefined,
+  null,
+  true,
+  "+01:00",
+  Symbol(),
+  3600_000_000_000n,
+  {},
+  { valueOf() { return 3600_000_000_000; } },
+].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const calendar = new Temporal.Calendar("iso8601");
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(TypeError, () => calendar.eraYear(datetime));
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/branding.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/branding.js
new file mode 100644
index 0000000000..c0ef6c041f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/branding.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Throw a TypeError if the receiver is invalid
+features: [Symbol, Temporal]
+---*/
+
+const eraYear = Temporal.Calendar.prototype.eraYear;
+
+assert.sameValue(typeof eraYear, "function");
+
+assert.throws(TypeError, () => eraYear.call(undefined), "undefined");
+assert.throws(TypeError, () => eraYear.call(null), "null");
+assert.throws(TypeError, () => eraYear.call(true), "true");
+assert.throws(TypeError, () => eraYear.call(""), "empty string");
+assert.throws(TypeError, () => eraYear.call(Symbol()), "symbol");
+assert.throws(TypeError, () => eraYear.call(1), "1");
+assert.throws(TypeError, () => eraYear.call({}), "plain object");
+assert.throws(TypeError, () => eraYear.call(Temporal.Calendar), "Temporal.Calendar");
+assert.throws(TypeError, () => eraYear.call(Temporal.Calendar.prototype), "Temporal.Calendar.prototype");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/builtin.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/builtin.js
new file mode 100644
index 0000000000..eb67b158e4
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/builtin.js
@@ -0,0 +1,36 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: >
+    Tests that Temporal.Calendar.prototype.eraYear
+    meets the requirements for built-in objects defined by the
+    introduction of chapter 17 of the ECMAScript Language Specification.
+info: |
+    Built-in functions that are not constructors do not have a "prototype" property unless
+    otherwise specified in the description of a particular function.
+
+    Unless specified otherwise, a built-in object that is callable as a function is a built-in
+    function object with the characteristics described in 10.3. Unless specified otherwise, the
+    [[Extensible]] internal slot of a built-in object initially has the value true.
+
+    Unless otherwise specified every built-in function and every built-in constructor has the
+    Function prototype object [...] as the value of its [[Prototype]] internal slot.
+features: [Temporal]
+---*/
+
+assert.sameValue(Object.isExtensible(Temporal.Calendar.prototype.eraYear),
+  true, "Built-in objects must be extensible.");
+
+assert.sameValue(Object.prototype.toString.call(Temporal.Calendar.prototype.eraYear),
+  "[object Function]", "Object.prototype.toString");
+
+assert.sameValue(Object.getPrototypeOf(Temporal.Calendar.prototype.eraYear),
+  Function.prototype, "prototype");
+
+assert.sameValue(Temporal.Calendar.prototype.eraYear.hasOwnProperty("prototype"),
+  false, "prototype property");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/calendar-datefromfields-called-with-options-undefined.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/calendar-datefromfields-called-with-options-undefined.js
new file mode 100644
index 0000000000..93e2bf8077
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/calendar-datefromfields-called-with-options-undefined.js
@@ -0,0 +1,18 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: >
+    Calendar.dateFromFields method is called with undefined as the options value
+    when call originates internally
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const calendar = TemporalHelpers.calendarFromFieldsUndefinedOptions();
+calendar.eraYear({ year: 2000, month: 5, day: 3, calendar });
+assert.sameValue(calendar.dateFromFieldsCallCount, 1);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..1fd4ce4133
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.erayear
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.eraYear({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.eraYear({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/length.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/length.js
new file mode 100644
index 0000000000..28d75bc46a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/length.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Temporal.Calendar.prototype.eraYear.length is 1
+info: |
+    Every built-in function object, including constructors, has a "length" property whose value is
+    an integer. Unless otherwise specified, this value is equal to the largest number of named
+    arguments shown in the subclause headings for the function description. Optional parameters
+    (which are indicated with brackets: [ ]) or rest parameters (which are shown using the form
+    «...name») are not included in the default argument count.
+
+    Unless otherwise specified, the "length" property of a built-in function object has the
+    attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.
+includes: [propertyHelper.js]
+features: [Temporal]
+---*/
+
+verifyProperty(Temporal.Calendar.prototype.eraYear, "length", {
+  value: 1,
+  writable: false,
+  enumerable: false,
+  configurable: true,
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/name.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/name.js
new file mode 100644
index 0000000000..017064e6e8
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/name.js
@@ -0,0 +1,26 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Temporal.Calendar.prototype.eraYear.name is "eraYear".
+info: |
+    Every built-in function object, including constructors, that is not identified as an anonymous
+    function has a "name" property whose value is a String. Unless otherwise specified, this value
+    is the name that is given to the function in this specification.
+
+    Unless otherwise specified, the "name" property of a built-in function object, if it exists,
+    has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.
+includes: [propertyHelper.js]
+features: [Temporal]
+---*/
+
+verifyProperty(Temporal.Calendar.prototype.eraYear, "name", {
+  value: "eraYear",
+  writable: false,
+  enumerable: false,
+  configurable: true,
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/not-a-constructor.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/not-a-constructor.js
new file mode 100644
index 0000000000..eacc07e32e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/not-a-constructor.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: >
+  Temporal.Calendar.prototype.eraYear does not implement [[Construct]], is not new-able
+info: |
+    Built-in function objects that are not identified as constructors do not implement the
+    [[Construct]] internal method unless otherwise specified in the description of a particular
+    function.
+includes: [isConstructor.js]
+features: [Reflect.construct, Temporal]
+---*/
+
+assert.throws(TypeError, () => {
+  new Temporal.Calendar.prototype.eraYear();
+}, "Calling as constructor");
+
+assert.sameValue(isConstructor(Temporal.Calendar.prototype.eraYear), false,
+  "isConstructor(Temporal.Calendar.prototype.eraYear)");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/prop-desc.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/prop-desc.js
new file mode 100644
index 0000000000..2e852441d3
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/prop-desc.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: The "eraYear" property of Temporal.Calendar.prototype
+includes: [propertyHelper.js]
+features: [Temporal]
+---*/
+
+assert.sameValue(
+  typeof Temporal.Calendar.prototype.eraYear,
+  "function",
+  "`typeof Calendar.prototype.eraYear` is `function`"
+);
+
+verifyProperty(Temporal.Calendar.prototype, "eraYear", {
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/shell.js
new file mode 100644
index 0000000000..32df7c4217
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/shell.js
@@ -0,0 +1,2182 @@
+// GENERATED, DO NOT EDIT
+// file: isConstructor.js
+// Copyright (C) 2017 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: |
+    Test if a given function is a constructor function.
+defines: [isConstructor]
+features: [Reflect.construct]
+---*/
+
+function isConstructor(f) {
+    if (typeof f !== "function") {
+      throw new Test262Error("isConstructor invoked with a non-function value");
+    }
+
+    try {
+        Reflect.construct(function(){}, [], f);
+    } catch (e) {
+        return false;
+    }
+    return true;
+}
+
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/year-zero.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/year-zero.js
new file mode 100644
index 0000000000..22609178b1
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/eraYear/year-zero.js
@@ -0,0 +1,26 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.erayear
+description: Negative zero, as an extended year, is rejected
+features: [Temporal, arrow-function]
+---*/
+
+const invalidStrings = [
+  "-000000-10-31",
+  "-000000-10-31T00:45",
+  "-000000-10-31T00:45+01:00",
+  "-000000-10-31T00:45+00:00[UTC]",
+];
+const instance = new Temporal.Calendar("iso8601");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.eraYear(arg),
+    "reject minus zero as extended year"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/inLeapYear/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/inLeapYear/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/inLeapYear/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/inLeapYear/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/inLeapYear/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..a6b94c84ce
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/inLeapYear/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.inleapyear
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.inLeapYear({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.inLeapYear({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/inLeapYear/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/inLeapYear/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/inLeapYear/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/gregorian-mutually-exclusive-fields.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/gregorian-mutually-exclusive-fields.js
new file mode 100644
index 0000000000..f1144a2503
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/gregorian-mutually-exclusive-fields.js
@@ -0,0 +1,108 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.mergefields
+description: Calendar-specific mutually exclusive keys in mergeFields
+features: [Temporal]
+---*/
+
+function assertEntriesEqual(actual, expectedEntries, message) {
+  const names = Object.getOwnPropertyNames(actual);
+  const symbols = Object.getOwnPropertySymbols(actual);
+  const actualKeys = names.concat(symbols);
+  assert.sameValue(
+    actualKeys.length,
+    expectedEntries.length,
+    `${message}: expected object to have ${expectedEntries.length} properties, not ${actualKeys.length}:`
+  );
+  for (var index = 0; index < actualKeys.length; index++) {
+    const actualKey = actualKeys[index];
+    const expectedKey = expectedEntries[index][0];
+    const expectedValue = expectedEntries[index][1];
+    assert.sameValue(actualKey, expectedKey, `${message}: key ${index}:`);
+    assert.sameValue(actual[actualKey], expectedValue, `${message}: value ${index}:`);
+  }
+}
+
+const instance = new Temporal.Calendar("gregory");
+
+const fullFields = {
+  era: "ce",
+  eraYear: 1981,
+  year: 1981,
+  month: 12,
+  monthCode: "M12",
+  day: 15,
+};
+
+assertEntriesEqual(instance.mergeFields(fullFields, { era: "bce", eraYear: 1 }), [
+  ["era", "bce"],
+  ["eraYear", 1],
+  ["month", 12],
+  ["monthCode", "M12"],
+  ["day", 15],
+], "era and eraYear together exclude year");
+
+assertEntriesEqual(instance.mergeFields(fullFields, { year: -2 }), [
+  ["year", -2],
+  ["month", 12],
+  ["monthCode", "M12"],
+  ["day", 15],
+], "year excludes era and eraYear");
+
+assertEntriesEqual(instance.mergeFields(fullFields, { month: 5 }), [
+  ["era", "ce"],
+  ["eraYear", 1981],
+  ["year", 1981],
+  ["month", 5],
+  ["day", 15],
+], "month excludes monthCode");
+
+assertEntriesEqual(instance.mergeFields(fullFields, { monthCode: "M05" }), [
+  ["era", "ce"],
+  ["eraYear", 1981],
+  ["year", 1981],
+  ["monthCode", "M05"],
+  ["day", 15],
+], "monthCode excludes month");
+
+// Specific test cases, of mergeFields on information that is not complete
+// enough to construct a PlainDate from, as discussed in
+// https://github.com/tc39/proposal-temporal/issues/2407:
+
+assertEntriesEqual(instance.mergeFields({ day: 25, monthCode: "M12", year: 1997, era: "bce" }, { eraYear: 1 }), [
+  ["day", 25],
+  ["monthCode", "M12"],
+  ["eraYear", 1],
+], "eraYear excludes year and era");
+
+assertEntriesEqual(instance.mergeFields({ day: 25, monthCode: "M12",  era: "bce" }, { eraYear: 1, year: 1997 }), [
+  ["day", 25],
+  ["monthCode", "M12"],
+  ["eraYear", 1],
+  ["year", 1997],
+], "eraYear and year both exclude era");
+
+assertEntriesEqual(instance.mergeFields({ day: 25, monthCode: "M12", eraYear: 1 }, { era: "bce", year: 1997 }), [
+  ["day", 25],
+  ["monthCode", "M12"],
+  ["era", "bce"],
+  ["year", 1997],
+], "era and year both exclude eraYear");
+
+assertEntriesEqual(instance.mergeFields({ day: 25, monthCode: "M12", year: 1997, eraYear: 1 }, { era: "bce" }), [
+  ["day", 25],
+  ["monthCode", "M12"],
+  ["era", "bce"],
+], "era excludes year and eraYear");
+
+assertEntriesEqual(instance.mergeFields({ day: 25, monthCode: "M12", year: 1997 }, { eraYear: 1, year: 2 }), [
+  ["day", 25],
+  ["monthCode", "M12"],
+  ["year", 2],
+  ["eraYear", 1],
+], "eraYear excludes year and era, year overwritten");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/japanese-mutually-exclusive-fields.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/japanese-mutually-exclusive-fields.js
new file mode 100644
index 0000000000..6742dc134a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/japanese-mutually-exclusive-fields.js
@@ -0,0 +1,80 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.mergefields
+description: Calendar-specific mutually exclusive keys in mergeFields
+features: [Temporal]
+---*/
+
+function assertEntriesEqual(actual, expectedEntries, message) {
+  const names = Object.getOwnPropertyNames(actual);
+  const symbols = Object.getOwnPropertySymbols(actual);
+  const actualKeys = names.concat(symbols);
+  assert.sameValue(
+    actualKeys.length,
+    expectedEntries.length,
+    `${message}: expected object to have ${expectedEntries.length} properties, not ${actualKeys.length}:`
+  );
+  for (var index = 0; index < actualKeys.length; index++) {
+    const actualKey = actualKeys[index];
+    const expectedKey = expectedEntries[index][0];
+    const expectedValue = expectedEntries[index][1];
+    assert.sameValue(actualKey, expectedKey, `${message}: key ${index}:`);
+    assert.sameValue(actual[actualKey], expectedValue, `${message}: value ${index}:`);
+  }
+}
+
+const instance = new Temporal.Calendar("japanese");
+
+const lastDayOfShowaFields = { era: "showa", eraYear: 64, year: 1989, month: 1, monthCode: "M01", day: 7 };
+
+assertEntriesEqual(instance.mergeFields(lastDayOfShowaFields, { day: 10 }), [
+  ["year", 1989],
+  ["month", 1],
+  ["monthCode", "M01"],
+  ["day", 10],
+], "day excludes era and eraYear");
+
+assertEntriesEqual(instance.mergeFields(lastDayOfShowaFields, { month: 2 }), [
+  ["year", 1989],
+  ["month", 2],
+  ["day", 7],
+], "month excludes monthCode, era, and eraYear");
+
+assertEntriesEqual(instance.mergeFields(lastDayOfShowaFields, { monthCode: "M03" }), [
+  ["year", 1989],
+  ["monthCode", "M03"],
+  ["day", 7],
+], "monthCode excludes month, era, and eraYear");
+
+assertEntriesEqual(instance.mergeFields(lastDayOfShowaFields, { year: 1988 }), [
+  ["year", 1988],
+  ["month", 1],
+  ["monthCode", "M01"],
+  ["day", 7],
+], "year excludes era and eraYear (within same era)");
+
+assertEntriesEqual(instance.mergeFields(lastDayOfShowaFields, { year: 1990 }), [
+  ["year", 1990],
+  ["month", 1],
+  ["monthCode", "M01"],
+  ["day", 7],
+], "year excludes era and eraYear (in a different era)");
+
+assertEntriesEqual(instance.mergeFields(lastDayOfShowaFields, { eraYear: 1 }), [
+  ["eraYear", 1],
+  ["month", 1],
+  ["monthCode", "M01"],
+  ["day", 7],
+], "eraYear excludes year and era");
+
+assertEntriesEqual(instance.mergeFields(lastDayOfShowaFields, { era: "heisei" }), [
+  ["era", "heisei"],
+  ["month", 1],
+  ["monthCode", "M01"],
+  ["day", 7],
+], "era excludes year and eraYear");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/mergeFields/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/month/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/month/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/month/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/month/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/month/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..81cf5f9062
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/month/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.month
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.month({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.month({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/month/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/month/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/month/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthCode/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthCode/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthCode/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthCode/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthCode/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..8705857e6b
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthCode/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.monthcode
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.monthCode({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.monthCode({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthCode/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthCode/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthCode/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/fields-underspecified.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/fields-underspecified.js
new file mode 100644
index 0000000000..7baa6db695
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/fields-underspecified.js
@@ -0,0 +1,23 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.monthdayfromfields
+description: Throw a RangeError if only one of era/eraYear fields is present
+features: [Temporal]
+---*/
+
+const tests = [
+  ["gregory", { year: 2000, month: 5, day: 2, era: "ce" }, "era present but not eraYear"],
+  ["gregory", { year: 2000, month: 5, day: 2, eraYear: 1 }, "eraYear present but not era"],
+  ["gregory", { month: 8, day: 1 }, "no monthCode or year specification, non-ISO Gregorian"],
+  ["hebrew", { month: 8, day: 1 }, "no monthCode or year specification, non-ISO non-Gregorian"],
+];
+
+for (const [calendarId, arg, description] of tests) {
+  const instance = new Temporal.Calendar(calendarId);
+  assert.throws(TypeError, () => instance.monthDayFromFields(arg), description);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..552873bb6f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/infinity-throws-rangeerror.js
@@ -0,0 +1,26 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.monthdayfromfields
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  ["constrain", "reject"].forEach((overflow) => {
+    assert.throws(RangeError, () => instance.monthDayFromFields({ ...base, eraYear: inf }, { overflow }), `eraYear property cannot be ${inf} (overflow ${overflow}`);
+
+    const calls = [];
+    const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+    assert.throws(RangeError, () => instance.monthDayFromFields({ ...base, eraYear: obj }, { overflow }));
+    assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/order-of-operations.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/order-of-operations.js
new file mode 100644
index 0000000000..6f0b350b22
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/order-of-operations.js
@@ -0,0 +1,79 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.monthdayfromfields
+description: Properties on objects passed to monthDayFromFields() are accessed in the correct order
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const expected = [
+  "get fields.day",
+  "get fields.day.valueOf",
+  "call fields.day.valueOf",
+  "get fields.era",
+  "get fields.era.toString",
+  "call fields.era.toString",
+  "get fields.eraYear",
+  "get fields.eraYear.valueOf",
+  "call fields.eraYear.valueOf",
+  "get fields.month",
+  "get fields.month.valueOf",
+  "call fields.month.valueOf",
+  "get fields.monthCode",
+  "get fields.monthCode.toString",
+  "call fields.monthCode.toString",
+  "get fields.year",
+  "get fields.year.valueOf",
+  "call fields.year.valueOf",
+  "get options.overflow",
+  "get options.overflow.toString",
+  "call options.overflow.toString",
+];
+const actual = [];
+
+const instance = new Temporal.Calendar("gregory");
+
+const fields = {
+  era: "ce",
+  eraYear: 1.7,
+  year: 1.7,
+  month: 1.7,
+  monthCode: "M01",
+  day: 1.7,
+};
+const arg1 = new Proxy(fields, {
+  get(target, key) {
+    actual.push(`get fields.${key}`);
+    if (key === "calendar") return instance;
+    const result = target[key];
+    return TemporalHelpers.toPrimitiveObserver(actual, result, `fields.${key}`);
+  },
+  has(target, key) {
+    actual.push(`has fields.${key}`);
+    return key in target;
+  },
+});
+
+const options = {
+  overflow: "reject",
+};
+const arg2 = new Proxy(options, {
+  get(target, key) {
+    actual.push(`get options.${key}`);
+    return TemporalHelpers.toPrimitiveObserver(actual, target[key], `options.${key}`);
+  },
+  has(target, key) {
+    actual.push(`has options.${key}`);
+    return key in target;
+  },
+});
+
+const result = instance.monthDayFromFields(arg1, arg2);
+TemporalHelpers.assertPlainMonthDay(result, "M01", 1, "monthDay result");
+assert.sameValue(result.getISOFields().calendar, "gregory", "calendar slot should store a string");
+assert.compareArray(actual, expected, "order of operations");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/reference-year-1972.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/reference-year-1972.js
new file mode 100644
index 0000000000..3dc69433a2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/reference-year-1972.js
@@ -0,0 +1,79 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.monthdayfromfields
+description: Deterministic choosing of the reference year
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const gregory = new Temporal.Calendar("gregory");
+
+const result1 = gregory.monthDayFromFields({ year: 2021, monthCode: "M02", day: 29 });
+TemporalHelpers.assertPlainMonthDay(
+  result1, "M02", 29,
+  "year is ignored and reference year should be 1972 if monthCode is given",
+  1972
+);
+
+const result2 = gregory.monthDayFromFields({ year: 2021, month: 2, day: 29 }, { overflow: "constrain" });
+TemporalHelpers.assertPlainMonthDay(
+  result2, "M02", 28,
+  "if monthCode is not given, year is used to determine if calendar date exists, but reference year should still be 1972",
+  1972
+);
+
+assert.throws(
+  RangeError,
+  () => gregory.monthDayFromFields({ year: 2021, month: 2, day: 29 }, { overflow: "reject" }),
+  "RangeError thrown if calendar date does not exist in given year and overflow is reject"
+);
+
+const hebrew = new Temporal.Calendar("hebrew");
+
+const result3 = hebrew.monthDayFromFields({ monthCode: "M01", day: 1 });
+TemporalHelpers.assertPlainMonthDay(
+  result3, "M01", 1,
+  "reference year should be 1972 if date exists in 1972",
+  1972
+);
+
+const result4 = hebrew.monthDayFromFields({ monthCode: "M05L", day: 1 });
+TemporalHelpers.assertPlainMonthDay(
+  result4, "M05L", 1,
+  "reference year should be the latest ISO year before 1972 if date does not exist in 1972",
+  1970
+);
+
+const result5 = hebrew.monthDayFromFields({ year: 5781, monthCode: "M02", day: 30 });
+TemporalHelpers.assertPlainMonthDay(
+  result5, "M02", 30,
+  "year is ignored if monthCode is given (Cheshvan 5781 has 29 days)",
+  1971
+);
+
+const result6 = hebrew.monthDayFromFields({ year: 5781, month: 2, day: 30 }, { overflow: "constrain" });
+TemporalHelpers.assertPlainMonthDay(
+  result6, "M02", 29,
+  "if monthCode is not given, year is used to determine if calendar date exists, but reference year still correct",
+  1972
+);
+
+assert.throws(
+  RangeError,
+  () => hebrew.monthDayFromFields({ year: 5781, month: 2, day: 30 }, { overflow: "reject" }),
+  "RangeError thrown if calendar date does not exist in given year and overflow is reject"
+);
+
+const result7 = hebrew.monthDayFromFields({ monthCode: "M04", day: 26 });
+TemporalHelpers.assertPlainMonthDay(
+  result7, "M04", 26,
+  "reference date should be the later one, if two options exist in ISO year 1972",
+  1972
+);
+assert.sameValue(result7.getISOFields().isoMonth, 12, "reference date should be 1972-12-31");
+assert.sameValue(result7.getISOFields().isoDay, 31, "reference date should be 1972-12-31");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthDayFromFields/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthsInYear/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthsInYear/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthsInYear/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthsInYear/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthsInYear/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..0962de7688
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthsInYear/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.monthsinyear
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.monthsInYear({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.monthsInYear({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthsInYear/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthsInYear/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/monthsInYear/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/weekOfYear/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/weekOfYear/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/weekOfYear/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/weekOfYear/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/weekOfYear/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..fe6de21dd7
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/weekOfYear/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.weekofyear
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.weekOfYear({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.weekOfYear({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/weekOfYear/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/weekOfYear/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/weekOfYear/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/year/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/year/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/year/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/year/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/year/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..193aa77241
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/year/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.year
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.year({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.year({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/year/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/year/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/year/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..f79cf04eb0
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/infinity-throws-rangeerror.js
@@ -0,0 +1,26 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.yearmonthfromfields
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  ["constrain", "reject"].forEach((overflow) => {
+    assert.throws(RangeError, () => instance.yearMonthFromFields({ ...base, eraYear: inf }, { overflow }), `eraYear property cannot be ${inf} (overflow ${overflow}`);
+
+    const calls = [];
+    const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+    assert.throws(RangeError, () => instance.yearMonthFromFields({ ...base, eraYear: obj }, { overflow }));
+    assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/one-of-era-erayear-undefined.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/one-of-era-erayear-undefined.js
new file mode 100644
index 0000000000..ab53618be8
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/one-of-era-erayear-undefined.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.yearmonthfromfields
+description: Throw a TypeError if only one of era/eraYear fields is present
+features: [Temporal]
+---*/
+
+const base = { year: 2000, month: 5, day: 2, era: 'ce' };
+const instance = new Temporal.Calendar('gregory');
+assert.throws(TypeError, () => {
+  instance.yearMonthFromFields({ ...base });
+});
+
+const base2 = { year: 2000, month: 5, day: 2, eraYear: 1 };
+assert.throws(TypeError, () => {
+  instance.yearMonthFromFields({ ...base2 });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/order-of-operations.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/order-of-operations.js
new file mode 100644
index 0000000000..64f82d9524
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/order-of-operations.js
@@ -0,0 +1,75 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.yearmonthfromfields
+description: Properties on objects passed to yearMonthFromFields() are accessed in the correct order
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const expected = [
+  "get fields.era",
+  "get fields.era.toString",
+  "call fields.era.toString",
+  "get fields.eraYear",
+  "get fields.eraYear.valueOf",
+  "call fields.eraYear.valueOf",
+  "get fields.month",
+  "get fields.month.valueOf",
+  "call fields.month.valueOf",
+  "get fields.monthCode",
+  "get fields.monthCode.toString",
+  "call fields.monthCode.toString",
+  "get fields.year",
+  "get fields.year.valueOf",
+  "call fields.year.valueOf",
+  "get options.overflow",
+  "get options.overflow.toString",
+  "call options.overflow.toString",
+];
+const actual = [];
+
+const instance = new Temporal.Calendar("gregory");
+
+const fields = {
+  era: "ce",
+  eraYear: 1.7,
+  year: 1.7,
+  month: 1.7,
+  monthCode: "M01",
+};
+const arg1 = new Proxy(fields, {
+  get(target, key) {
+    actual.push(`get fields.${key}`);
+    if (key === "calendar") return instance;
+    const result = target[key];
+    return TemporalHelpers.toPrimitiveObserver(actual, result, `fields.${key}`);
+  },
+  has(target, key) {
+    actual.push(`has fields.${key}`);
+    return key in target;
+  },
+});
+
+const options = {
+  overflow: "reject",
+};
+const arg2 = new Proxy(options, {
+  get(target, key) {
+    actual.push(`get options.${key}`);
+    return TemporalHelpers.toPrimitiveObserver(actual, target[key], `options.${key}`);
+  },
+  has(target, key) {
+    actual.push(`has options.${key}`);
+    return key in target;
+  },
+});
+
+const result = instance.yearMonthFromFields(arg1, arg2);
+TemporalHelpers.assertPlainYearMonth(result, 1, 1, "M01", "yearMonth result", "ce", 1);
+assert.sameValue(result.getISOFields().calendar, "gregory", "calendar slot should store a string");
+assert.compareArray(actual, expected, "order of operations");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/reference-day.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/reference-day.js
new file mode 100644
index 0000000000..a2b709ff40
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/reference-day.js
@@ -0,0 +1,164 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.calendar.prototype.yearmonthfromfields
+description: Reference ISO day is chosen to be the first of the calendar month
+info: |
+  6.d. Perform ! CreateDataPropertyOrThrow(_fields_, *"day"*, *1*<sub>𝔽</sub>).
+    e. Let _result_ be ? CalendarDateToISO(_calendar_.[[Identifier]], _fields_, _options_).
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const gregory = new Temporal.Calendar("gregory");
+
+const result1 = gregory.yearMonthFromFields({ year: 2023, monthCode: "M01", day: 13 });
+TemporalHelpers.assertPlainYearMonth(
+  result1,
+  2023, 1, "M01",
+  "reference day is 1 even if day is given",
+  "ce", 2023, /* reference day = */ 1
+);
+
+const result2 = gregory.yearMonthFromFields({ year: 2021, monthCode: "M02", day: 50 }, { overflow: "constrain" });
+TemporalHelpers.assertPlainYearMonth(
+  result2,
+  2021, 2, "M02",
+  "reference day is set correctly even if day is out of range (overflow constrain)",
+  "ce", 2021, /* reference day = */ 1
+);
+
+const result3 = gregory.yearMonthFromFields({ year: 2021, monthCode: "M02", day: 50 }, { overflow: "reject" });
+TemporalHelpers.assertPlainYearMonth(
+  result3,
+  2021, 2, "M02",
+  "reference day is set correctly even if day is out of range (overflow reject)",
+  "ce", 2021, /* reference day = */ 1
+);
+
+const hebrew = new Temporal.Calendar("hebrew");
+
+const result4 = hebrew.yearMonthFromFields({ year: 5782, monthCode: "M04", day: 20 });
+TemporalHelpers.assertPlainYearMonth(
+  result4,
+  5782, 4, "M04",
+  "reference day is the first of the calendar month even if day is given",
+  /* era = */ undefined, /* era year = */ undefined, /* reference day = */ 5
+);
+const isoFields = result4.getISOFields();
+assert.sameValue(isoFields.isoYear, 2021, "Tevet 5782 begins in ISO year 2021");
+assert.sameValue(isoFields.isoMonth, 12, "Tevet 5782 begins in ISO month 12");
+
+const result5 = hebrew.yearMonthFromFields({ year: 5783, monthCode: "M05L" }, { overflow: "constrain" });
+TemporalHelpers.assertPlainYearMonth(
+  result5,
+  5783, 6, "M06",
+  "month code M05L does not exist in year 5783 (overflow constrain); Hebrew calendar constrains Adar I to Adar",
+  /* era = */ undefined, /* era year = */ undefined, /* reference day = */ 22
+);
+
+assert.throws(
+  RangeError,
+  () => hebrew.yearMonthFromFields({ year: 5783, monthCode: "M05L" }, { overflow: "reject" }),
+  "month code M05L does not exist in year 5783 (overflow reject)",
+);
+
+const result6 = hebrew.yearMonthFromFields({ year: 5783, month: 13 }, { overflow: "constrain" });
+TemporalHelpers.assertPlainYearMonth(
+  result6,
+  5783, 12, "M12",
+  "month 13 does not exist in year 5783 (overflow constrain)",
+  /* era = */ undefined, /* era year = */ undefined, /* reference day = */ 18
+);
+
+assert.throws(
+  RangeError,
+  () => hebrew.yearMonthFromFields({ year: 5783, month: 13 }, { overflow: "reject" }),
+  "month 13 does not exist in year 5783 (overflow reject)",
+);
+
+const result7 = hebrew.yearMonthFromFields({ year: 5782, monthCode: "M04", day: 50 }, { overflow: "constrain" });
+TemporalHelpers.assertPlainYearMonth(
+  result7,
+  5782, 4, "M04",
+  "reference day is set correctly even if day is out of range (overflow constrain)",
+  /* era = */ undefined, /* era year = */ undefined, /* reference day = */ 5
+);
+
+const result8 = hebrew.yearMonthFromFields({ year: 5782, monthCode: "M04", day: 50 }, { overflow: "reject" });
+TemporalHelpers.assertPlainYearMonth(
+  result8,
+  5782, 4, "M04",
+  "reference day is set correctly even if day is out of range (overflow reject)",
+  /* era = */ undefined, /* era year = */ undefined, /* reference day = */ 5
+);
+
+const chinese = new Temporal.Calendar("chinese");
+
+// Month codes, month indices, and the ISO reference days of the months in 2022
+const months2022TestData = [
+  // TODO: Sources conflict over whether M01L and M12L exist in _any_ year.
+  // Clarify this, and delete if appropriate. ICU has them, but may be wrong.
+  ["M01", 1, 1],
+  ["M02", 2, 3],
+  ["M03", 3, 1],
+  ["M04", 4, 1],
+  ["M05", 5, 30],
+  ["M06", 6, 29],
+  ["M07", 7, 29],
+  ["M08", 8, 27],
+  ["M09", 9, 26],
+  ["M10", 10, 25],
+  ["M11", 11, 24],
+  ["M12", 12, 23],
+];
+for (const [nonLeapMonthCode, month, referenceISODay] of months2022TestData) {
+  const leapMonthCode = nonLeapMonthCode + "L";
+  const fields = { year: 2022, monthCode: leapMonthCode };
+
+  const result = chinese.yearMonthFromFields(fields, { overflow: "constrain" });
+  TemporalHelpers.assertPlainYearMonth(
+    result,
+    2022, month, nonLeapMonthCode,
+    `Chinese intercalary month ${leapMonthCode} does not exist in year 2022 (overflow constrain)`,
+    /* era = */ undefined, /* era year = */ undefined, referenceISODay
+  );
+
+  assert.throws(
+    RangeError,
+    () => chinese.yearMonthFromFields(fields, { overflow: "reject" }),
+    `Chinese intercalary month ${leapMonthCode} does not exist in year 2022 (overflow reject)`
+  );
+}
+
+// Years in which leap months exist according to ICU
+const leapMonthsTestData = [
+  ["M01L", 2148, 2, 20],
+  ["M02L", 2023, 3, 22],
+  ["M03L", 1993, 4, 22],
+  ["M04L", 2020, 5, 23],
+  ["M05L", 2009, 6, 23],
+  ["M06L", 2017, 7, 23],
+  ["M07L", 2006, 8, 24],
+  ["M08L", 1995, 9, 25],
+  ["M09L", 2014, 10, 24],
+  ["M10L", 1984, 11, 23],
+  ["M11L", 2033, 12, 22],
+  ["M12L", 1889, 13, 21, 1890, 1],
+];
+for (const [monthCode, year, month, referenceISODay, isoYear = year, isoMonth = month] of leapMonthsTestData) {
+  const result = chinese.yearMonthFromFields({ year, monthCode });
+  TemporalHelpers.assertPlainYearMonth(
+    result,
+    year, month, monthCode,
+    `Date of sample Chinese intercalary month ${monthCode}`,
+    /* era = */ undefined, /* era year = */ undefined, referenceISODay
+  );
+  const isoFields = result.getISOFields();
+  assert.sameValue(isoFields.isoYear, isoYear, `${year}-${monthCode} starts in ISO year ${isoYear}`);
+  assert.sameValue(isoFields.isoMonth, isoMonth, `${year}-${monthCode} starts in ISO month ${isoMonth}`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearMonthFromFields/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearOfWeek/browser.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearOfWeek/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearOfWeek/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearOfWeek/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearOfWeek/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..d8be8ffea1
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearOfWeek/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.calendar.prototype.yearofweek
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Calendar("gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.yearOfWeek({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.yearOfWeek({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearOfWeek/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearOfWeek/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/prototype/yearOfWeek/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Calendar/shell.js b/js/src/tests/test262/intl402/Temporal/Calendar/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Calendar/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/browser.js b/js/src/tests/test262/intl402/Temporal/Duration/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/compare/browser.js b/js/src/tests/test262/intl402/Temporal/Duration/compare/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/compare/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/compare/relativeto-hour.js b/js/src/tests/test262/intl402/Temporal/Duration/compare/relativeto-hour.js
new file mode 100644
index 0000000000..678252ad2a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/compare/relativeto-hour.js
@@ -0,0 +1,34 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.duration.compare
+description: relativeTo with hours.
+features: [Temporal]
+---*/
+
+const oneDay = new Temporal.Duration(0, 0, 0, 1);
+const hours24 = new Temporal.Duration(0, 0, 0, 0, 24);
+
+assert.sameValue(
+  Temporal.Duration.compare(oneDay, hours24, { relativeTo: Temporal.ZonedDateTime.from('2017-01-01T00:00[America/Montevideo]') }),
+  0,
+  'relativeTo does not affect days if ZonedDateTime, and duration encompasses no DST change');
+assert.sameValue(
+  Temporal.Duration.compare(oneDay, hours24, { relativeTo: Temporal.ZonedDateTime.from('2019-11-03T00:00[America/Vancouver]') }),
+  1,
+  'relativeTo does affect days if ZonedDateTime, and duration encompasses DST change');
+assert.sameValue(
+  Temporal.Duration.compare(oneDay, hours24, { relativeTo: '2019-11-03T00:00[America/Vancouver]' }),
+  1,
+  'casts relativeTo to ZonedDateTime from string');
+assert.sameValue(
+  Temporal.Duration.compare(oneDay, hours24, {
+    relativeTo: { year: 2019, month: 11, day: 3, timeZone: 'America/Vancouver' }
+  }),
+  1,
+  'casts relativeTo to ZonedDateTime from object');
+
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/compare/relativeto-sub-minute-offset.js b/js/src/tests/test262/intl402/Temporal/Duration/compare/relativeto-sub-minute-offset.js
new file mode 100644
index 0000000000..da46868524
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/compare/relativeto-sub-minute-offset.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.duration.compare
+description: relativeTo string accepts an inexact UTC offset rounded to hours and minutes
+features: [Temporal]
+---*/
+
+const duration1 = new Temporal.Duration(0, 0, 0, 31);
+const duration2 = new Temporal.Duration(0, 1);
+
+let result;
+let relativeTo;
+
+const action = (relativeTo) => Temporal.Duration.compare(duration1, duration2, { relativeTo });
+
+relativeTo = "1970-01-01T00:00:00-00:45[Africa/Monrovia]";
+result = action(relativeTo);
+assert.sameValue(result, 0, "rounded HH:MM is accepted in string offset");
+
+relativeTo = "1970-01-01T00:00:00-00:44:30[Africa/Monrovia]";
+result = action(relativeTo);
+assert.sameValue(result, 0, "unrounded HH:MM:SS is accepted in string offset");
+
+const timeZone = Temporal.TimeZone.from("Africa/Monrovia");
+relativeTo = { year: 1970, month: 1, day: 1, offset: "+00:45", timeZone };
+assert.throws(RangeError, () => action(relativeTo), "rounded HH:MM not accepted as offset in property bag");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/compare/shell.js b/js/src/tests/test262/intl402/Temporal/Duration/compare/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/compare/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/browser.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/relativeto-infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/relativeto-infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..83bf1b50ef
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/relativeto-infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.duration.prototype.add
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 987, 654, 321);
+const base = { era: "ad", month: 5, day: 2, hour: 15, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.add(instance, { relativeTo: { ...base, eraYear: inf } }), `eraYear property cannot be ${inf} in relativeTo`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.add(instance, { relativeTo: { ...base, eraYear: obj } }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/relativeto-string-datetime.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/relativeto-string-datetime.js
new file mode 100644
index 0000000000..752b920126
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/relativeto-string-datetime.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.duration.prototype.add
+description: >
+    Conversion of ISO date-time strings as relativeTo option to
+    Temporal.ZonedDateTime or Temporal.PlainDateTime instances
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 0, 0, 1);
+
+let relativeTo = "2019-11-01T00:00[America/Vancouver]";
+const result4 = instance.add(new Temporal.Duration(0, 0, 0, 0, -24), { relativeTo });
+TemporalHelpers.assertDuration(result4, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, "date-time + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00Z[America/Vancouver]";
+const result5 = instance.add(new Temporal.Duration(0, 0, 0, 0, -24), { relativeTo });
+TemporalHelpers.assertDuration(result5, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, "date-time + Z + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00-07:00[America/Vancouver]";
+const result6 = instance.add(new Temporal.Duration(0, 0, 0, 0, -24), { relativeTo });
+TemporalHelpers.assertDuration(result6, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, "date-time + offset + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00+04:15[America/Vancouver]";
+assert.throws(RangeError, () => instance.add(new Temporal.Duration(0, 0, 0, 0, -24), { relativeTo }), "date-time + offset + IANA annotation throws if wall time and exact time mismatch");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/relativeto-sub-minute-offset.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/relativeto-sub-minute-offset.js
new file mode 100644
index 0000000000..8ad6ef73f5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/relativeto-sub-minute-offset.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.duration.prototype.add
+description: relativeTo string accepts an inexact UTC offset rounded to hours and minutes
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 0, 0, 1);
+let result;
+let relativeTo;
+const action = (relativeTo) => instance.add(new Temporal.Duration(0, 0, 0, 0, -24), { relativeTo });
+
+relativeTo = "1970-01-01T00:00-00:45:00[-00:45]";
+result = action(relativeTo);
+TemporalHelpers.assertDateDuration(result, 1, 0, 0, 0, "ISO string offset accepted with zero seconds (string)");
+
+relativeTo = { year: 1970, month: 1, day: 1, offset: "+00:45:00.000000000", timeZone: "+00:45" };
+result = action(relativeTo);
+TemporalHelpers.assertDateDuration(result, 1, 0, 0, 0, "ISO string offset accepted with zero seconds (property bag)");
+
+relativeTo = "1970-01-01T00:00+00:44:30.123456789[+00:45]";
+assert.throws(RangeError, () => action(relativeTo), "rounding is not accepted between ISO offset and time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/shell.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/add/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/browser.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/browser.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/relativeto-infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/relativeto-infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..2561e27221
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/relativeto-infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.duration.prototype.round
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 987, 654, 321);
+const base = { era: "ad", month: 5, day: 2, hour: 15, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.round({ smallestUnit: "seconds", relativeTo: { ...base, eraYear: inf } }), `eraYear property cannot be ${inf} in relativeTo`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.round({ smallestUnit: "seconds", relativeTo: { ...base, eraYear: obj } }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/relativeto-string-datetime.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/relativeto-string-datetime.js
new file mode 100644
index 0000000000..691a40ad9e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/relativeto-string-datetime.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.duration.prototype.round
+description: >
+    Conversion of ISO date-time strings as relativeTo option to
+    Temporal.ZonedDateTime or Temporal.PlainDateTime instances
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 0, 0, 0, 24);
+
+let relativeTo = "2019-11-01T00:00[America/Vancouver]";
+const result4 = instance.round({ largestUnit: "years", relativeTo });
+TemporalHelpers.assertDuration(result4, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, "date-time + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00Z[America/Vancouver]";
+const result5 = instance.round({ largestUnit: "years", relativeTo });
+TemporalHelpers.assertDuration(result5, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, "date-time + Z + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00-07:00[America/Vancouver]";
+const result6 = instance.round({ largestUnit: "years", relativeTo });
+TemporalHelpers.assertDuration(result6, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, "date-time + offset + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00+04:15[America/Vancouver]";
+assert.throws(RangeError, () => instance.round({ largestUnit: "years", relativeTo }), "date-time + offset + IANA annotation throws if wall time and exact time mismatch");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/relativeto-sub-minute-offset.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/relativeto-sub-minute-offset.js
new file mode 100644
index 0000000000..19875672b1
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/relativeto-sub-minute-offset.js
@@ -0,0 +1,42 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.duration.prototype.round
+description: relativeTo string accepts an inexact UTC offset rounded to hours and minutes
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 0, 0, 0, 24);
+
+let result;
+let relativeTo;
+
+const action = (relativeTo) => instance.round({ largestUnit: "years", relativeTo });
+
+relativeTo = "1970-01-01T00:00-00:45:00[-00:45]";
+result = action(relativeTo);
+TemporalHelpers.assertDateDuration(result, 1, 0, 0, 1, "ISO string offset accepted with zero seconds (string)");
+
+relativeTo = { year: 1970, month: 1, day: 1, offset: "+00:45:00.000000000", timeZone: "+00:45" };
+result = action(relativeTo);
+TemporalHelpers.assertDateDuration(result, 1, 0, 0, 1, "ISO string offset accepted with zero seconds (property bag)");
+
+relativeTo = "1970-01-01T00:00:00-00:45[Africa/Monrovia]";
+result = action(relativeTo);
+TemporalHelpers.assertDateDuration(result, 1, 0, 0, 1, "rounded HH:MM is accepted in string offset");
+
+relativeTo = "1970-01-01T00:00:00-00:44:30[Africa/Monrovia]";
+result = action(relativeTo);
+TemporalHelpers.assertDateDuration(result, 1, 0, 0, 1, "unrounded HH:MM:SS is accepted in string offset");
+
+relativeTo = "1970-01-01T00:00+00:44:30.123456789[+00:45]";
+assert.throws(RangeError, () => action(relativeTo), "rounding is not accepted between ISO offset and time zone");
+
+const timeZone = Temporal.TimeZone.from("Africa/Monrovia");
+relativeTo = { year: 1970, month: 1, day: 1, offset: "+00:45", timeZone };
+assert.throws(RangeError, () => action(relativeTo), "rounded HH:MM not accepted as offset in property bag");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/shell.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/round/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/shell.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/browser.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/relativeto-infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/relativeto-infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..bc74500a01
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/relativeto-infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.duration.prototype.subtract
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 987, 654, 321);
+const base = { era: "ad", month: 5, day: 2, hour: 15, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.subtract(instance, { relativeTo: { ...base, eraYear: inf } }), `eraYear property cannot be ${inf} in relativeTo`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.subtract(instance, { relativeTo: { ...base, eraYear: obj } }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/relativeto-string-datetime.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/relativeto-string-datetime.js
new file mode 100644
index 0000000000..c04ca96e3b
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/relativeto-string-datetime.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.duration.prototype.subtract
+description: >
+    Conversion of ISO date-time strings as relativeTo option to
+    Temporal.ZonedDateTime or Temporal.PlainDateTime instances
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 0, 0, 1);
+
+let relativeTo = "2019-11-01T00:00[America/Vancouver]";
+const result4 = instance.subtract(new Temporal.Duration(0, 0, 0, 0, 24), { relativeTo });
+TemporalHelpers.assertDuration(result4, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, "date-time + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00Z[America/Vancouver]";
+const result5 = instance.subtract(new Temporal.Duration(0, 0, 0, 0, 24), { relativeTo });
+TemporalHelpers.assertDuration(result5, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, "date-time + Z + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00-07:00[America/Vancouver]";
+const result6 = instance.subtract(new Temporal.Duration(0, 0, 0, 0, 24), { relativeTo });
+TemporalHelpers.assertDuration(result6, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, "date-time + offset + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00+04:15[America/Vancouver]";
+assert.throws(RangeError, () => instance.subtract(new Temporal.Duration(0, 0, 0, 0, 24), { relativeTo }), "date-time + offset + IANA annotation throws if wall time and exact time mismatch");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/relativeto-sub-minute-offset.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/relativeto-sub-minute-offset.js
new file mode 100644
index 0000000000..bea613cd5d
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/relativeto-sub-minute-offset.js
@@ -0,0 +1,29 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.duration.prototype.subtract
+description: relativeTo string accepts an inexact UTC offset rounded to hours and minutes
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 0, 0, 1);
+
+let result;
+let relativeTo;
+const action = (relativeTo) => instance.subtract(new Temporal.Duration(0, 0, 0, 0, 24), { relativeTo });
+
+relativeTo = "1970-01-01T00:00-00:45:00[-00:45]";
+result = action(relativeTo);
+TemporalHelpers.assertDateDuration(result, 1, 0, 0, 0, "ISO string offset accepted with zero seconds (string)");
+
+relativeTo = { year: 1970, month: 1, day: 1, offset: "+00:45:00.000000000", timeZone: "+00:45" };
+result = action(relativeTo);
+TemporalHelpers.assertDateDuration(result, 1, 0, 0, 0, "ISO string offset accepted with zero seconds (property bag)");
+
+relativeTo = "1970-01-01T00:00+00:44:30.123456789[+00:45]";
+assert.throws(RangeError, () => action(relativeTo), "rounding is not accepted between ISO offset and time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/shell.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/subtract/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/browser.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/relativeto-infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/relativeto-infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..fd500c83a1
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/relativeto-infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.duration.prototype.total
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 987, 654, 321);
+const base = { era: "ad", month: 5, day: 2, hour: 15, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.total({ unit: "seconds", relativeTo: { ...base, eraYear: inf } }), `eraYear property cannot be ${inf} in relativeTo`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.total({ unit: "seconds", relativeTo: { ...base, eraYear: obj } }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/relativeto-string-datetime.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/relativeto-string-datetime.js
new file mode 100644
index 0000000000..be00a9ed23
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/relativeto-string-datetime.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.duration.prototype.total
+description: >
+    Conversion of ISO date-time strings as relativeTo option to
+    Temporal.ZonedDateTime or Temporal.PlainDateTime instances
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 0, 0, 0, 24);
+
+let relativeTo = "2019-11-01T00:00[America/Vancouver]";
+const result4 = instance.total({ unit: "days", relativeTo });
+assert.sameValue(result4, 366.96, "date-time + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00Z[America/Vancouver]";
+const result5 = instance.total({ unit: "days", relativeTo });
+assert.sameValue(result5, 366.96, "date-time + Z + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00-07:00[America/Vancouver]";
+const result6 = instance.total({ unit: "days", relativeTo });
+assert.sameValue(result6, 366.96, "date-time + offset + IANA annotation is a zoned relativeTo");
+
+relativeTo = "2019-11-01T00:00+04:15[America/Vancouver]";
+assert.throws(RangeError, () => instance.total({ unit: "days", relativeTo }), "date-time + offset + IANA annotation throws if wall time and exact time mismatch");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/relativeto-sub-minute-offset.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/relativeto-sub-minute-offset.js
new file mode 100644
index 0000000000..92c3b5af79
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/relativeto-sub-minute-offset.js
@@ -0,0 +1,41 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.duration.prototype.total
+description: relativeTo string accepts an inexact UTC offset rounded to hours and minutes
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Duration(1, 0, 0, 0, 24);
+
+let result;
+let relativeTo;
+
+const action = (relativeTo) => instance.total({ unit: "days", relativeTo });
+
+relativeTo = "1970-01-01T00:00-00:45:00[-00:45]";
+result = action(relativeTo);
+assert.sameValue(result, 366, "ISO string offset accepted with zero seconds (string)");
+
+relativeTo = { year: 1970, month: 1, day: 1, offset: "+00:45:00.000000000", timeZone: "+00:45" };
+result = action(relativeTo);
+assert.sameValue(result, 366, "ISO string offset accepted with zero seconds (property bag)");
+
+relativeTo = "1970-01-01T00:00:00-00:45[Africa/Monrovia]";
+result = action(relativeTo);
+assert.sameValue(result, 366, "rounded HH:MM is accepted in string offset");
+
+relativeTo = "1970-01-01T00:00:00-00:44:30[Africa/Monrovia]";
+result = action(relativeTo);
+assert.sameValue(result, 366, "unrounded HH:MM:SS is accepted in string offset");
+
+relativeTo = "1970-01-01T00:00+00:44:30.123456789[+00:45]";
+assert.throws(RangeError, () => action(relativeTo), "rounding is not accepted between ISO offset and time zone");
+
+const timeZone = Temporal.TimeZone.from("Africa/Monrovia");
+relativeTo = { year: 1970, month: 1, day: 1, offset: "+00:45", timeZone };
+assert.throws(RangeError, () => action(relativeTo), "rounded HH:MM not accepted as offset in property bag");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/shell.js b/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/prototype/total/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/Duration/shell.js b/js/src/tests/test262/intl402/Temporal/Duration/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Duration/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/browser.js b/js/src/tests/test262/intl402/Temporal/Instant/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/browser.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/shell.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/browser.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/locales-undefined.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/locales-undefined.js
new file mode 100644
index 0000000000..a111b53390
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/locales-undefined.js
@@ -0,0 +1,21 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.instant.prototype.tolocalestring
+description: Omitting the locales argument defaults to the DateTimeFormat default
+features: [BigInt, Temporal]
+---*/
+
+const instant = new Temporal.Instant(957270896_987_650_000n);
+const defaultFormatter = new Intl.DateTimeFormat([], Object.create(null));
+const expected = defaultFormatter.format(instant);
+
+const actualExplicit = instant.toLocaleString(undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = instant.toLocaleString();
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/options-conflict.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/options-conflict.js
new file mode 100644
index 0000000000..ec694466cf
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/options-conflict.js
@@ -0,0 +1,50 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Kate Miháliková. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sup-temporal.instant.prototype.tolocalestring
+description: >
+    Conflicting properties of dateStyle must be rejected with a TypeError for the options argument
+info: |
+    Using sec-temporal-getdatetimeformatpattern:
+    GetDateTimeFormatPattern ( dateStyle, timeStyle, matcher, opt, dataLocaleData, hc )
+
+    1. If dateStyle is not undefined or timeStyle is not undefined, then
+      a. For each row in Table 7, except the header row, do
+        i. Let prop be the name given in the Property column of the row.
+        ii. Let p be opt.[[<prop>]].
+        iii. If p is not undefined, then
+          1. Throw a TypeError exception.
+features: [BigInt, Temporal]
+---*/
+
+// Table 14 - Supported fields + example value for each field
+const conflictingOptions = [
+  [ "weekday", "short" ],
+  [ "era", "short" ],
+  [ "year", "numeric" ],
+  [ "month", "numeric" ],
+  [ "day", "numeric" ],
+  [ "hour", "numeric" ],
+  [ "minute", "numeric" ],
+  [ "second", "numeric" ],
+  [ "dayPeriod", "short" ],
+  [ "fractionalSecondDigits", 3 ],
+];
+const instant = new Temporal.Instant(957270896_987_650_000n);
+
+assert.sameValue(typeof instant.toLocaleString("en", { dateStyle: "short" }), "string");
+assert.sameValue(typeof instant.toLocaleString("en", { timeStyle: "short" }), "string");
+
+for (const [ option, value ] of conflictingOptions) {
+  assert.throws(TypeError, function() {
+    instant.toLocaleString("en", { [option]: value, dateStyle: "short" });
+  }, `instant.toLocaleString("en", { ${option}: "${value}",  dateStyle: "short" }) throws TypeError`);
+
+  assert.throws(TypeError, function() {
+    instant.toLocaleString("en", { [option]: value, timeStyle: "short" });
+  }, `instant.toLocaleString("en", { ${option}: "${value}",  timeStyle: "short" }) throws TypeError`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/options-undefined.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/options-undefined.js
new file mode 100644
index 0000000000..50a69ef1b7
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/options-undefined.js
@@ -0,0 +1,21 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.instant.prototype.tolocalestring
+description: Verify that undefined options are handled correctly.
+features: [BigInt, Temporal]
+---*/
+
+const instant = new Temporal.Instant(957270896_987_650_000n);
+const defaultFormatter = new Intl.DateTimeFormat('en', Object.create(null));
+const expected = defaultFormatter.format(instant);
+
+const actualExplicit = instant.toLocaleString('en', undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = instant.toLocaleString('en');
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/shell.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toLocaleString/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/browser.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/shell.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/timezone-offset.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/timezone-offset.js
new file mode 100644
index 0000000000..927a2ff6c3
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/timezone-offset.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.instant.prototype.tostring
+description: The time zone offset part of the string serialization (IANA time zones)
+features: [BigInt, Temporal]
+---*/
+
+const instant = new Temporal.Instant(0n);
+
+function test(timeZoneIdentifier, expected, description) {
+  const timeZone = new Temporal.TimeZone(timeZoneIdentifier);
+  assert.sameValue(instant.toString({ timeZone }), expected, description);
+}
+
+test("Europe/Berlin", "1970-01-01T01:00:00+01:00", "positive offset");
+test("America/New_York", "1969-12-31T19:00:00-05:00", "negative offset");
+test("Africa/Monrovia", "1969-12-31T23:15:30-00:45", "sub-minute offset");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/timezone-string-datetime.js
new file mode 100644
index 0000000000..f25a7e147f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toString/timezone-string-datetime.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.instant.prototype.tostring
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Instant(0n);
+
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+const result1 = instance.toString({ timeZone });
+assert.sameValue(result1.substr(-6), "-08:00", "date-time + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+const result2 = instance.toString({ timeZone });
+assert.sameValue(result2.substr(-6), "-08:00", "date-time + Z + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+const result3 = instance.toString({ timeZone });
+assert.sameValue(result3.substr(-6), "-08:00", "date-time + offset + IANA annotation is the IANA time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTime/browser.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTime/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTime/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTime/shell.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTime/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTime/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTime/timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTime/timezone-string-datetime.js
new file mode 100644
index 0000000000..cb854630ff
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTime/timezone-string-datetime.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.instant.prototype.tozoneddatetime
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Instant(0n);
+
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+const result1 = instance.toZonedDateTime({ timeZone, calendar: "iso8601" });
+assert.sameValue(result1.timeZoneId, "America/Vancouver", "date-time + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+const result2 = instance.toZonedDateTime({ timeZone, calendar: "iso8601" });
+assert.sameValue(result2.timeZoneId, "America/Vancouver", "date-time + Z + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+const result3 = instance.toZonedDateTime({ timeZone, calendar: "iso8601" });
+assert.sameValue(result3.timeZoneId, "America/Vancouver", "date-time + offset + IANA annotation is the IANA time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTimeISO/browser.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTimeISO/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTimeISO/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTimeISO/shell.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTimeISO/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTimeISO/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTimeISO/timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTimeISO/timezone-string-datetime.js
new file mode 100644
index 0000000000..7f141cb1ec
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/prototype/toZonedDateTimeISO/timezone-string-datetime.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.instant.prototype.tozoneddatetimeiso
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+const instance = new Temporal.Instant(0n);
+
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+const result1 = instance.toZonedDateTimeISO(timeZone);
+assert.sameValue(result1.timeZoneId, "America/Vancouver", "date-time + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+const result2 = instance.toZonedDateTimeISO(timeZone);
+assert.sameValue(result2.timeZoneId, "America/Vancouver", "date-time + Z + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+const result3 = instance.toZonedDateTimeISO(timeZone);
+assert.sameValue(result3.timeZoneId, "America/Vancouver", "date-time + offset + IANA annotation is the IANA time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Instant/shell.js b/js/src/tests/test262/intl402/Temporal/Instant/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Instant/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/browser.js b/js/src/tests/test262/intl402/Temporal/Now/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/plainDate/browser.js b/js/src/tests/test262/intl402/Temporal/Now/plainDate/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/plainDate/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/plainDate/calendar-string.js b/js/src/tests/test262/intl402/Temporal/Now/plainDate/calendar-string.js
new file mode 100644
index 0000000000..b454ed12dd
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/plainDate/calendar-string.js
@@ -0,0 +1,15 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.now.plaindate
+description: String calendar argument
+features: [Temporal]
+---*/
+
+const date = Temporal.Now.plainDate("gregory");
+assert(date instanceof Temporal.PlainDate);
+assert.sameValue(date.calendarId, "gregory");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Now/plainDate/shell.js b/js/src/tests/test262/intl402/Temporal/Now/plainDate/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/plainDate/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/plainDateTime/browser.js b/js/src/tests/test262/intl402/Temporal/Now/plainDateTime/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/plainDateTime/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/plainDateTime/calendar-string.js b/js/src/tests/test262/intl402/Temporal/Now/plainDateTime/calendar-string.js
new file mode 100644
index 0000000000..207269c56b
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/plainDateTime/calendar-string.js
@@ -0,0 +1,15 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.now.plaindatetime
+description: String calendar argument
+features: [Temporal]
+---*/
+
+const dt = Temporal.Now.plainDateTime("gregory");
+assert(dt instanceof Temporal.PlainDateTime);
+assert.sameValue(dt.calendarId, "gregory");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Now/plainDateTime/shell.js b/js/src/tests/test262/intl402/Temporal/Now/plainDateTime/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/plainDateTime/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/plainDateTimeISO/browser.js b/js/src/tests/test262/intl402/Temporal/Now/plainDateTimeISO/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/plainDateTimeISO/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/plainDateTimeISO/shell.js b/js/src/tests/test262/intl402/Temporal/Now/plainDateTimeISO/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/plainDateTimeISO/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/plainDateTimeISO/timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/Now/plainDateTimeISO/timezone-string-datetime.js
new file mode 100644
index 0000000000..41a9ddb98c
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/plainDateTimeISO/timezone-string-datetime.js
@@ -0,0 +1,63 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-temporal.now.plaindatetimeiso
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances
+features: [Temporal]
+---*/
+
+let timeZone = "2021-08-19T17:30";
+assert.throws(RangeError, () => Temporal.Now.plainDateTimeISO(timeZone), "bare date-time string is not a time zone");
+
+[
+  "2021-08-19T17:30-07:00:01",
+  "2021-08-19T17:30-07:00:00",
+  "2021-08-19T17:30-07:00:00.1",
+  "2021-08-19T17:30-07:00:00.0",
+  "2021-08-19T17:30-07:00:00.01",
+  "2021-08-19T17:30-07:00:00.00",
+  "2021-08-19T17:30-07:00:00.001",
+  "2021-08-19T17:30-07:00:00.000",
+  "2021-08-19T17:30-07:00:00.0001",
+  "2021-08-19T17:30-07:00:00.0000",
+  "2021-08-19T17:30-07:00:00.00001",
+  "2021-08-19T17:30-07:00:00.00000",
+  "2021-08-19T17:30-07:00:00.000001",
+  "2021-08-19T17:30-07:00:00.000000",
+  "2021-08-19T17:30-07:00:00.0000001",
+  "2021-08-19T17:30-07:00:00.0000000",
+  "2021-08-19T17:30-07:00:00.00000001",
+  "2021-08-19T17:30-07:00:00.00000000",
+  "2021-08-19T17:30-07:00:00.000000001",
+  "2021-08-19T17:30-07:00:00.000000000",
+].forEach((timeZone) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.Now.plainDateTimeISO(timeZone),
+    `ISO string ${timeZone} with a sub-minute offset is not a valid time zone`
+  );
+});
+
+// The following are all valid strings so should not throw:
+
+[
+  "2021-08-19T17:30Z",
+  "2021-08-19T1730Z",
+  "2021-08-19T17:30-07:00",
+  "2021-08-19T1730-07:00",
+  "2021-08-19T17:30-0700",
+  "2021-08-19T1730-0700",
+  "2021-08-19T17:30[America/Vancouver]",
+  "2021-08-19T1730[America/Vancouver]",
+  "2021-08-19T17:30Z[America/Vancouver]",
+  "2021-08-19T1730Z[America/Vancouver]",
+  "2021-08-19T17:30-07:00[America/Vancouver]",
+  "2021-08-19T1730-07:00[America/Vancouver]",
+  "2021-08-19T17:30-0700[America/Vancouver]",
+  "2021-08-19T1730-0700[America/Vancouver]",
+].forEach((timeZone) => {
+  Temporal.Now.plainDateTimeISO(timeZone);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Now/shell.js b/js/src/tests/test262/intl402/Temporal/Now/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/browser.js b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/calendar-string.js b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/calendar-string.js
new file mode 100644
index 0000000000..a8e94a4567
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/calendar-string.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.now.zoneddatetime
+description: String calendar argument
+features: [Temporal]
+---*/
+
+const zdt = Temporal.Now.zonedDateTime("gregory");
+const tz = Temporal.Now.timeZoneId();
+assert(zdt instanceof Temporal.ZonedDateTime);
+assert.sameValue(typeof zdt.getISOFields().calendar, "string", "calendar slot should store a string");
+assert.sameValue(zdt.calendarId, "gregory");
+assert.sameValue(typeof zdt.getISOFields().timeZone, "string", "time zone slot should store a string");
+assert.sameValue(zdt.timeZoneId, tz);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/calendar-timezone-string.js b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/calendar-timezone-string.js
new file mode 100644
index 0000000000..a97baba9b7
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/calendar-timezone-string.js
@@ -0,0 +1,18 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.now.zoneddatetime
+description: String calendar and time zone arguments
+features: [Temporal]
+---*/
+
+const zdt = Temporal.Now.zonedDateTime("gregory", "America/Los_Angeles");
+assert(zdt instanceof Temporal.ZonedDateTime);
+assert.sameValue(typeof zdt.getISOFields().calendar, "string", "calendar slot should store a string");
+assert.sameValue(zdt.calendarId, "gregory");
+assert.sameValue(typeof zdt.getISOFields().timeZone, "string", "time zone slot should store a string");
+assert.sameValue(zdt.timeZoneId, "America/Los_Angeles");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/shell.js b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/timezone-string-datetime.js
new file mode 100644
index 0000000000..90b8859b0f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTime/timezone-string-datetime.js
@@ -0,0 +1,23 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.now.zoneddatetime
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+const result1 = Temporal.Now.zonedDateTime("iso8601", timeZone);
+assert.sameValue(result1.timeZoneId, "America/Vancouver", "date-time + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+const result2 = Temporal.Now.zonedDateTime("iso8601", timeZone);
+assert.sameValue(result2.timeZoneId, "America/Vancouver", "date-time + Z + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+const result3 = Temporal.Now.zonedDateTime("iso8601", timeZone);
+assert.sameValue(result3.timeZoneId, "America/Vancouver", "date-time + offset + IANA annotation is the IANA time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/browser.js b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/shell.js b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/timezone-string-datetime.js
new file mode 100644
index 0000000000..ba406fe2a5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/timezone-string-datetime.js
@@ -0,0 +1,23 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.now.zoneddatetimeiso
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+const result1 = Temporal.Now.zonedDateTimeISO(timeZone);
+assert.sameValue(result1.timeZoneId, "America/Vancouver", "date-time + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+const result2 = Temporal.Now.zonedDateTimeISO(timeZone);
+assert.sameValue(result2.timeZoneId, "America/Vancouver", "date-time + Z + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+const result3 = Temporal.Now.zonedDateTimeISO(timeZone);
+assert.sameValue(result3.timeZoneId, "America/Vancouver", "date-time + offset + IANA annotation is the IANA time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/timezone-string.js b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/timezone-string.js
new file mode 100644
index 0000000000..85b7d58b03
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/Now/zonedDateTimeISO/timezone-string.js
@@ -0,0 +1,18 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.now.zoneddatetimeiso
+description: String calendar argument
+features: [Temporal]
+---*/
+
+const zdt = Temporal.Now.zonedDateTimeISO("America/Los_Angeles");
+assert(zdt instanceof Temporal.ZonedDateTime);
+assert.sameValue(typeof zdt.getISOFields().calendar, "string", "calendar slot should store a string");
+assert.sameValue(zdt.calendarId, "iso8601");
+assert.sameValue(typeof zdt.getISOFields().timeZone, "string", "time zone slot should store a string");
+assert.sameValue(zdt.timeZoneId, "America/Los_Angeles");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/compare/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/compare/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/compare/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/compare/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainDate/compare/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..dd90b5bd85
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/compare/infinity-throws-rangeerror.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if any value in a property bag for either argument is Infinity or -Infinity
+esid: sec-temporal.plaindate.compare
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const other = new Temporal.PlainDate(2000, 5, 2, "gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => Temporal.PlainDate.compare({ ...base, eraYear: inf }, other), `eraYear property cannot be ${inf}`);
+
+  assert.throws(RangeError, () => Temporal.PlainDate.compare(other, { ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls1 = [];
+  const obj1 = TemporalHelpers.toPrimitiveObserver(calls1, inf, "eraYear");
+  assert.throws(RangeError, () => Temporal.PlainDate.compare({ ...base, eraYear: obj1 }, other));
+  assert.compareArray(calls1, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+
+  const calls2 = [];
+  const obj2 = TemporalHelpers.toPrimitiveObserver(calls2, inf, "eraYear");
+  assert.throws(RangeError, () => Temporal.PlainDate.compare(other, { ...base, eraYear: obj2 }));
+  assert.compareArray(calls2, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/compare/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/compare/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/compare/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/from/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/from/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/from/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/from/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainDate/from/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..c38a5e633e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/from/infinity-throws-rangeerror.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plaindate.from
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  ["constrain", "reject"].forEach((overflow) => {
+    assert.throws(RangeError, () => Temporal.PlainDate.from({ ...base, eraYear: inf }, { overflow }), `eraYear property cannot be ${inf} (overflow ${overflow}`);
+
+    const calls = [];
+    const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+    assert.throws(RangeError, () => Temporal.PlainDate.from({ ...base, eraYear: obj }, { overflow }));
+    assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/from/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/from/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/from/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/equals/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/equals/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/equals/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/equals/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/equals/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..2d4fac8989
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/equals/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plaindate.prototype.equals
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainDate(2000, 5, 2, "gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.equals({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.equals({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/equals/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/equals/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/equals/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/branding.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/branding.js
new file mode 100644
index 0000000000..64a07fd3b2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/branding.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindate.prototype.era
+description: Throw a TypeError if the receiver is invalid
+features: [Symbol, Temporal]
+---*/
+
+const era = Object.getOwnPropertyDescriptor(Temporal.PlainDate.prototype, "era").get;
+
+assert.sameValue(typeof era, "function");
+
+assert.throws(TypeError, () => era.call(undefined), "undefined");
+assert.throws(TypeError, () => era.call(null), "null");
+assert.throws(TypeError, () => era.call(true), "true");
+assert.throws(TypeError, () => era.call(""), "empty string");
+assert.throws(TypeError, () => era.call(Symbol()), "symbol");
+assert.throws(TypeError, () => era.call(1), "1");
+assert.throws(TypeError, () => era.call({}), "plain object");
+assert.throws(TypeError, () => era.call(Temporal.PlainDate), "Temporal.PlainDate");
+assert.throws(TypeError, () => era.call(Temporal.PlainDate.prototype), "Temporal.PlainDate.prototype");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/prop-desc.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/prop-desc.js
new file mode 100644
index 0000000000..769f188f70
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/prop-desc.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindate.prototype.era
+description: The "era" property of Temporal.PlainDate.prototype
+features: [Temporal]
+---*/
+
+const descriptor = Object.getOwnPropertyDescriptor(Temporal.PlainDate.prototype, "era");
+assert.sameValue(typeof descriptor.get, "function");
+assert.sameValue(descriptor.set, undefined);
+assert.sameValue(descriptor.enumerable, false);
+assert.sameValue(descriptor.configurable, true);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/validate-calendar-value.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/validate-calendar-value.js
new file mode 100644
index 0000000000..d4d0aab391
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/era/validate-calendar-value.js
@@ -0,0 +1,54 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindate.prototype.era
+description: Validate result returned from calendar era() method
+features: [Temporal]
+---*/
+
+const badResults = [
+  [null, TypeError],
+  [false, TypeError],
+  [Infinity, TypeError],
+  [-Infinity, TypeError],
+  [NaN, TypeError],
+  [-7, TypeError],
+  [-0.1, TypeError],
+  [Symbol("foo"), TypeError],
+  [7n, TypeError],
+  [{}, TypeError],
+  [true, TypeError],
+  [7.1, TypeError],
+  [{valueOf() { return "7"; }}, TypeError],
+];
+
+badResults.forEach(([result, error]) => {
+  const calendar = new class extends Temporal.Calendar {
+    era() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainDate(1981, 12, 15, calendar);
+  assert.throws(error, () => instance.era, `${typeof result} ${String(result)} not converted to string`);
+});
+
+const preservedResults = [
+  undefined,
+  "string",
+  "7",
+  "7.5",
+];
+
+preservedResults.forEach(result => {
+  const calendar = new class extends Temporal.Calendar {
+    era() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainDate(1981, 12, 15, calendar);
+  assert.sameValue(instance.era, result, `${typeof result} ${String(result)} preserved`);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/branding.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/branding.js
new file mode 100644
index 0000000000..fd68d2761c
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/branding.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindate.prototype.erayear
+description: Throw a TypeError if the receiver is invalid
+features: [Symbol, Temporal]
+---*/
+
+const eraYear = Object.getOwnPropertyDescriptor(Temporal.PlainDate.prototype, "eraYear").get;
+
+assert.sameValue(typeof eraYear, "function");
+
+assert.throws(TypeError, () => eraYear.call(undefined), "undefined");
+assert.throws(TypeError, () => eraYear.call(null), "null");
+assert.throws(TypeError, () => eraYear.call(true), "true");
+assert.throws(TypeError, () => eraYear.call(""), "empty string");
+assert.throws(TypeError, () => eraYear.call(Symbol()), "symbol");
+assert.throws(TypeError, () => eraYear.call(1), "1");
+assert.throws(TypeError, () => eraYear.call({}), "plain object");
+assert.throws(TypeError, () => eraYear.call(Temporal.PlainDate), "Temporal.PlainDate");
+assert.throws(TypeError, () => eraYear.call(Temporal.PlainDate.prototype), "Temporal.PlainDate.prototype");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/prop-desc.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/prop-desc.js
new file mode 100644
index 0000000000..1b182c306a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/prop-desc.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindate.prototype.erayear
+description: The "eraYear" property of Temporal.PlainDate.prototype
+features: [Temporal]
+---*/
+
+const descriptor = Object.getOwnPropertyDescriptor(Temporal.PlainDate.prototype, "eraYear");
+assert.sameValue(typeof descriptor.get, "function");
+assert.sameValue(descriptor.set, undefined);
+assert.sameValue(descriptor.enumerable, false);
+assert.sameValue(descriptor.configurable, true);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/validate-calendar-value.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/validate-calendar-value.js
new file mode 100644
index 0000000000..48bb01304e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/eraYear/validate-calendar-value.js
@@ -0,0 +1,54 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindate.prototype.erayear
+description: Validate result returned from calendar eraYear() method
+features: [Temporal]
+---*/
+
+const badResults = [
+  [null, TypeError],
+  [false, TypeError],
+  [Infinity, RangeError],
+  [-Infinity, RangeError],
+  [NaN, RangeError],
+  [-0.1, RangeError],
+  ["string", TypeError],
+  [Symbol("foo"), TypeError],
+  [7n, TypeError],
+  [{}, TypeError],
+  [true, TypeError],
+  [7.1, RangeError],
+  ["7", TypeError],
+  ["7.5", TypeError],
+  [{valueOf() { return 7; }}, TypeError],
+];
+
+badResults.forEach(([result, error]) => {
+  const calendar = new class extends Temporal.Calendar {
+    eraYear() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainDate(1981, 12, 15, calendar);
+  assert.throws(error, () => instance.eraYear, `${typeof result} ${String(result)} not converted to integer`);
+});
+
+const preservedResults = [
+  undefined,
+  -7,
+];
+
+preservedResults.forEach(result => {
+  const calendar = new class extends Temporal.Calendar {
+    eraYear() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainDate(1981, 12, 15, calendar);
+  assert.sameValue(instance.eraYear, result, `${typeof result} ${String(result)} preserved`);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/since/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/since/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/since/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/since/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/since/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..4df1a71f81
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/since/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plaindate.prototype.since
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainDate(2000, 5, 2, "gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.since({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.since({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/since/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/since/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/since/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/calendar-mismatch.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/calendar-mismatch.js
new file mode 100644
index 0000000000..14df21c029
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/calendar-mismatch.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.tolocalestring
+description: Calendar must match the locale calendar if not "iso8601"
+features: [Temporal, Intl-enumeration]
+---*/
+
+const localeCalendar = new Intl.DateTimeFormat().resolvedOptions().calendar;
+assert.notSameValue(localeCalendar, "iso8601", "no locale has the ISO calendar");
+
+const sameCalendarInstance = new Temporal.PlainDate(2000, 5, 2, localeCalendar);
+const result = sameCalendarInstance.toLocaleString();
+assert.sameValue(typeof result, "string", "toLocaleString() succeeds when instance has the same calendar as locale");
+
+const isoInstance = new Temporal.PlainDate(2000, 5, 2, "iso8601");
+assert.sameValue(isoInstance.toLocaleString(), result, "toLocaleString() succeeds when instance has the ISO calendar")
+
+// Pick a different calendar that is not ISO and not the locale's calendar
+const calendars = new Set(Intl.supportedValuesOf("calendar"));
+calendars.delete("iso8601");
+calendars.delete(localeCalendar);
+const differentCalendar = calendars.values().next().value;
+
+const differentCalendarInstance = new Temporal.PlainDate(2000, 5, 2, differentCalendar);
+assert.throws(RangeError, () => differentCalendarInstance.toLocaleString(), "calendar mismatch");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/locales-undefined.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/locales-undefined.js
new file mode 100644
index 0000000000..b33b9557f3
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/locales-undefined.js
@@ -0,0 +1,21 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.tolocalestring
+description: Omitting the locales argument defaults to the DateTimeFormat default
+features: [Temporal]
+---*/
+
+const date = new Temporal.PlainDate(2000, 5, 2);
+const defaultFormatter = new Intl.DateTimeFormat([], Object.create(null));
+const expected = defaultFormatter.format(date);
+
+const actualExplicit = date.toLocaleString(undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = date.toLocaleString();
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/options-conflict.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/options-conflict.js
new file mode 100644
index 0000000000..962d255a4e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/options-conflict.js
@@ -0,0 +1,40 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Kate Miháliková. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sup-temporal.plaindate.prototype.tolocalestring
+description: >
+    Conflicting properties of dateStyle must be rejected with a TypeError for the options argument
+info: |
+    Using sec-temporal-getdatetimeformatpattern:
+    GetDateTimeFormatPattern ( dateStyle, timeStyle, matcher, opt, dataLocaleData, hc )
+
+    1. If dateStyle is not undefined or timeStyle is not undefined, then
+      a. For each row in Table 7, except the header row, do
+        i. Let prop be the name given in the Property column of the row.
+        ii. Let p be opt.[[<prop>]].
+        iii. If p is not undefined, then
+          1. Throw a TypeError exception.
+features: [Temporal]
+---*/
+
+// Table 14 - Supported fields + example value for each field
+const conflictingOptions = [
+  [ "weekday", "short" ],
+  [ "era", "short" ],
+  [ "year", "numeric" ],
+  [ "month", "numeric" ],
+  [ "day", "numeric" ],
+];
+const date = new Temporal.PlainDate(2000, 5, 2);
+
+assert.sameValue(typeof date.toLocaleString("en", { dateStyle: "short" }), "string");
+
+for (const [ option, value ] of conflictingOptions) {
+  assert.throws(TypeError, function() {
+    date.toLocaleString("en", { [option]: value, dateStyle: "short" });
+  }, `date.toLocaleString("en", { ${option}: "${value}",  dateStyle: "short" }) throws TypeError`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/options-undefined.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/options-undefined.js
new file mode 100644
index 0000000000..87b5084099
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/options-undefined.js
@@ -0,0 +1,21 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.tolocalestring
+description: Verify that undefined options are handled correctly.
+features: [Temporal]
+---*/
+
+const date = new Temporal.PlainDate(2000, 5, 2);
+const defaultFormatter = new Intl.DateTimeFormat('en', Object.create(null));
+const expected = defaultFormatter.format(date);
+
+const actualExplicit = date.toLocaleString('en', undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = date.toLocaleString('en');
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/resolved-time-zone.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/resolved-time-zone.js
new file mode 100644
index 0000000000..926728d9e4
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/resolved-time-zone.js
@@ -0,0 +1,16 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.tolocalestring
+description: A time zone in resolvedOptions with a large offset still produces the correct string
+locale: [en]
+features: [Temporal]
+---*/
+
+const date = new Temporal.PlainDate(2021, 8, 4);
+const result = date.toLocaleString("en", { timeZone: "Pacific/Apia" });
+assert.sameValue(result, "8/4/2021");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toLocaleString/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toZonedDateTime/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toZonedDateTime/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toZonedDateTime/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toZonedDateTime/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toZonedDateTime/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toZonedDateTime/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toZonedDateTime/timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toZonedDateTime/timezone-string-datetime.js
new file mode 100644
index 0000000000..74e42258ac
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/toZonedDateTime/timezone-string-datetime.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.tozoneddatetime
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainDate(2000, 5, 2);
+
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+const result1 = instance.toZonedDateTime(timeZone);
+assert.sameValue(result1.timeZoneId, "America/Vancouver", "date-time + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+const result2 = instance.toZonedDateTime(timeZone);
+assert.sameValue(result2.timeZoneId, "America/Vancouver", "date-time + Z + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+const result3 = instance.toZonedDateTime(timeZone);
+assert.sameValue(result3.timeZoneId, "America/Vancouver", "date-time + offset + IANA annotation is the IANA time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/until/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/until/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/until/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/until/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/until/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..98495547f3
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/until/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plaindate.prototype.until
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainDate(2000, 5, 2, "gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.until({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.until({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/until/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/until/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/until/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/with/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/with/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/with/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/with/cross-era-boundary.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/with/cross-era-boundary.js
new file mode 100644
index 0000000000..d372a581cf
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/with/cross-era-boundary.js
@@ -0,0 +1,20 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.with
+description: Behaviour when property bag forms a date out of bounds of the current era
+features: [Temporal]
+---*/
+
+// Last day of Showa era
+const instance = new Temporal.PlainDate(1989, 1, 7, "japanese");
+
+const result1 = instance.with({ day: 10 });
+assert.notSameValue(result1.era, instance.era, "resulting day should have crossed an era boundary");
+
+const result2 = instance.with({ month: 2 });
+assert.notSameValue(result2.era, instance.era, "resulting month should have crossed an era boundary");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/with/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/with/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/prototype/with/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDate/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDate/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDate/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/compare/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/compare/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/compare/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/compare/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/compare/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..43d5dd142a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/compare/infinity-throws-rangeerror.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if any value in a property bag for either argument is Infinity or -Infinity
+esid: sec-temporal.plaindatetime.compare
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const other = new Temporal.PlainDateTime(2000, 5, 2, 15, 0, 0, 0, 0, 0, "gregory");
+const base = { era: "ad", month: 5, day: 2, hour: 15, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => Temporal.PlainDateTime.compare({ ...base, eraYear: inf }, other), `eraYear property cannot be ${inf}`);
+
+  assert.throws(RangeError, () => Temporal.PlainDateTime.compare(other, { ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls1 = [];
+  const obj1 = TemporalHelpers.toPrimitiveObserver(calls1, inf, "eraYear");
+  assert.throws(RangeError, () => Temporal.PlainDateTime.compare({ ...base, eraYear: obj1 }, other));
+  assert.compareArray(calls1, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+
+  const calls2 = [];
+  const obj2 = TemporalHelpers.toPrimitiveObserver(calls2, inf, "eraYear");
+  assert.throws(RangeError, () => Temporal.PlainDateTime.compare(other, { ...base, eraYear: obj2 }));
+  assert.compareArray(calls2, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/compare/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/compare/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/compare/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/from/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/from/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/from/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/from/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/from/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..8dab95abcb
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/from/infinity-throws-rangeerror.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plaindatetime.from
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const base = { era: "ad", month: 5, day: 2, hour: 15, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  ["constrain", "reject"].forEach((overflow) => {
+    assert.throws(RangeError, () => Temporal.PlainDateTime.from({ ...base, eraYear: inf }, { overflow }), `eraYear property cannot be ${inf} (overflow ${overflow}`);
+
+    const calls = [];
+    const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+    assert.throws(RangeError, () => Temporal.PlainDateTime.from({ ...base, eraYear: obj }, { overflow }));
+    assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/from/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/from/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/from/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/equals/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/equals/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/equals/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/equals/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/equals/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..d83ac3ad15
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/equals/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plaindatetime.prototype.equals
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainDateTime(2000, 5, 2, 15, 0, 0, 0, 0, 0, "gregory");
+const base = { era: "ad", month: 5, day: 2, hour: 15, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.equals({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.equals({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/equals/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/equals/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/equals/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/branding.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/branding.js
new file mode 100644
index 0000000000..9dec07bdfd
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/branding.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindatetime.prototype.era
+description: Throw a TypeError if the receiver is invalid
+features: [Symbol, Temporal]
+---*/
+
+const era = Object.getOwnPropertyDescriptor(Temporal.PlainDateTime.prototype, "era").get;
+
+assert.sameValue(typeof era, "function");
+
+assert.throws(TypeError, () => era.call(undefined), "undefined");
+assert.throws(TypeError, () => era.call(null), "null");
+assert.throws(TypeError, () => era.call(true), "true");
+assert.throws(TypeError, () => era.call(""), "empty string");
+assert.throws(TypeError, () => era.call(Symbol()), "symbol");
+assert.throws(TypeError, () => era.call(1), "1");
+assert.throws(TypeError, () => era.call({}), "plain object");
+assert.throws(TypeError, () => era.call(Temporal.PlainDateTime), "Temporal.PlainDateTime");
+assert.throws(TypeError, () => era.call(Temporal.PlainDateTime.prototype), "Temporal.PlainDateTime.prototype");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/prop-desc.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/prop-desc.js
new file mode 100644
index 0000000000..4565b39f6a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/prop-desc.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindatetime.prototype.era
+description: The "era" property of Temporal.PlainDateTime.prototype
+features: [Temporal]
+---*/
+
+const descriptor = Object.getOwnPropertyDescriptor(Temporal.PlainDateTime.prototype, "era");
+assert.sameValue(typeof descriptor.get, "function");
+assert.sameValue(descriptor.set, undefined);
+assert.sameValue(descriptor.enumerable, false);
+assert.sameValue(descriptor.configurable, true);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/validate-calendar-value.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/validate-calendar-value.js
new file mode 100644
index 0000000000..e887eab427
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/era/validate-calendar-value.js
@@ -0,0 +1,54 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindatetime.prototype.era
+description: Validate result returned from calendar era() method
+features: [Temporal]
+---*/
+
+const badResults = [
+  [null, TypeError],
+  [false, TypeError],
+  [Infinity, TypeError],
+  [-Infinity, TypeError],
+  [NaN, TypeError],
+  [-7, TypeError],
+  [-0.1, TypeError],
+  [Symbol("foo"), TypeError],
+  [7n, TypeError],
+  [{}, TypeError],
+  [true, TypeError],
+  [7.1, TypeError],
+  [{valueOf() { return "7"; }}, TypeError],
+];
+
+badResults.forEach(([result, error]) => {
+  const calendar = new class extends Temporal.Calendar {
+    era() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainDateTime(1981, 12, 15, 14, 15, 45, 987, 654, 321, calendar);
+  assert.throws(error, () => instance.era, `${typeof result} ${String(result)} not converted to string`);
+});
+
+const preservedResults = [
+  undefined,
+  "string",
+  "7",
+  "7.5",
+];
+
+preservedResults.forEach(result => {
+  const calendar = new class extends Temporal.Calendar {
+    era() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainDateTime(1981, 12, 15, 14, 15, 45, 987, 654, 321, calendar);
+  assert.sameValue(instance.era, result, `${typeof result} ${String(result)} preserved`);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/branding.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/branding.js
new file mode 100644
index 0000000000..80fa8e8340
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/branding.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindatetime.prototype.erayear
+description: Throw a TypeError if the receiver is invalid
+features: [Symbol, Temporal]
+---*/
+
+const eraYear = Object.getOwnPropertyDescriptor(Temporal.PlainDateTime.prototype, "eraYear").get;
+
+assert.sameValue(typeof eraYear, "function");
+
+assert.throws(TypeError, () => eraYear.call(undefined), "undefined");
+assert.throws(TypeError, () => eraYear.call(null), "null");
+assert.throws(TypeError, () => eraYear.call(true), "true");
+assert.throws(TypeError, () => eraYear.call(""), "empty string");
+assert.throws(TypeError, () => eraYear.call(Symbol()), "symbol");
+assert.throws(TypeError, () => eraYear.call(1), "1");
+assert.throws(TypeError, () => eraYear.call({}), "plain object");
+assert.throws(TypeError, () => eraYear.call(Temporal.PlainDateTime), "Temporal.PlainDateTime");
+assert.throws(TypeError, () => eraYear.call(Temporal.PlainDateTime.prototype), "Temporal.PlainDateTime.prototype");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/prop-desc.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/prop-desc.js
new file mode 100644
index 0000000000..0500021f93
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/prop-desc.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindatetime.prototype.erayear
+description: The "eraYear" property of Temporal.PlainDateTime.prototype
+features: [Temporal]
+---*/
+
+const descriptor = Object.getOwnPropertyDescriptor(Temporal.PlainDateTime.prototype, "eraYear");
+assert.sameValue(typeof descriptor.get, "function");
+assert.sameValue(descriptor.set, undefined);
+assert.sameValue(descriptor.enumerable, false);
+assert.sameValue(descriptor.configurable, true);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/validate-calendar-value.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/validate-calendar-value.js
new file mode 100644
index 0000000000..3c32f8d788
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/eraYear/validate-calendar-value.js
@@ -0,0 +1,54 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plaindatetime.prototype.erayear
+description: Validate result returned from calendar eraYear() method
+features: [Temporal]
+---*/
+
+const badResults = [
+  [null, TypeError],
+  [false, TypeError],
+  [Infinity, RangeError],
+  [-Infinity, RangeError],
+  [NaN, RangeError],
+  [-0.1, RangeError],
+  ["string", TypeError],
+  [Symbol("foo"), TypeError],
+  [7n, TypeError],
+  [{}, TypeError],
+  [true, TypeError],
+  [7.1, RangeError],
+  ["7", TypeError],
+  ["7.5", TypeError],
+  [{valueOf() { return 7; }}, TypeError],
+];
+
+badResults.forEach(([result, error]) => {
+  const calendar = new class extends Temporal.Calendar {
+    eraYear() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainDateTime(1981, 12, 15, 14, 15, 45, 987, 654, 321, calendar);
+  assert.throws(error, () => instance.eraYear, `${typeof result} ${String(result)} not converted to integer`);
+});
+
+const preservedResults = [
+  undefined,
+  -7,
+];
+
+preservedResults.forEach(result => {
+  const calendar = new class extends Temporal.Calendar {
+    eraYear() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainDateTime(1981, 12, 15, 14, 15, 45, 987, 654, 321, calendar);
+  assert.sameValue(instance.eraYear, result, `${typeof result} ${String(result)} preserved`);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/since/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/since/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/since/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/since/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/since/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..b1d0140229
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/since/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plaindatetime.prototype.since
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainDateTime(2000, 5, 2, 15, 0, 0, 0, 0, 0, "gregory");
+const base = { era: "ad", month: 5, day: 2, hour: 15, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.since({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.since({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/since/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/since/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/since/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/calendar-mismatch.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/calendar-mismatch.js
new file mode 100644
index 0000000000..e50cc4237f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/calendar-mismatch.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.tolocalestring
+description: Calendar must match the locale calendar if not "iso8601"
+features: [Temporal, Intl-enumeration]
+---*/
+
+const localeCalendar = new Intl.DateTimeFormat().resolvedOptions().calendar;
+assert.notSameValue(localeCalendar, "iso8601", "no locale has the ISO calendar");
+
+const sameCalendarInstance = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, localeCalendar);
+const result = sameCalendarInstance.toLocaleString();
+assert.sameValue(typeof result, "string", "toLocaleString() succeeds when instance has the same calendar as locale");
+
+const isoInstance = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, "iso8601");
+assert.sameValue(isoInstance.toLocaleString(), result, "toLocaleString() succeeds when instance has the ISO calendar")
+
+// Pick a different calendar that is not ISO and not the locale's calendar
+const calendars = new Set(Intl.supportedValuesOf("calendar"));
+calendars.delete("iso8601");
+calendars.delete(localeCalendar);
+const differentCalendar = calendars.values().next().value;
+
+const differentCalendarInstance = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, differentCalendar);
+assert.throws(RangeError, () => differentCalendarInstance.toLocaleString(), "calendar mismatch");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/locales-undefined.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/locales-undefined.js
new file mode 100644
index 0000000000..b9e6b75381
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/locales-undefined.js
@@ -0,0 +1,21 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.tolocalestring
+description: Omitting the locales argument defaults to the DateTimeFormat default
+features: [Temporal]
+---*/
+
+const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321);
+const defaultFormatter = new Intl.DateTimeFormat([], Object.create(null));
+const expected = defaultFormatter.format(datetime);
+
+const actualExplicit = datetime.toLocaleString(undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = datetime.toLocaleString();
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/options-conflict.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/options-conflict.js
new file mode 100644
index 0000000000..e0bbf809f1
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/options-conflict.js
@@ -0,0 +1,50 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Kate Miháliková. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sup-temporal.plaindatetime.prototype.tolocalestring
+description: >
+    Conflicting properties of dateStyle must be rejected with a TypeError for the options argument
+info: |
+    Using sec-temporal-getdatetimeformatpattern:
+    GetDateTimeFormatPattern ( dateStyle, timeStyle, matcher, opt, dataLocaleData, hc )
+
+    1. If dateStyle is not undefined or timeStyle is not undefined, then
+      a. For each row in Table 7, except the header row, do
+        i. Let prop be the name given in the Property column of the row.
+        ii. Let p be opt.[[<prop>]].
+        iii. If p is not undefined, then
+          1. Throw a TypeError exception.
+features: [Temporal]
+---*/
+
+// Table 14 - Supported fields + example value for each field
+const conflictingOptions = [
+  [ "weekday", "short" ],
+  [ "era", "short" ],
+  [ "year", "numeric" ],
+  [ "month", "numeric" ],
+  [ "day", "numeric" ],
+  [ "hour", "numeric" ],
+  [ "minute", "numeric" ],
+  [ "second", "numeric" ],
+  [ "dayPeriod", "short" ],
+  [ "fractionalSecondDigits", 3 ],
+];
+const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321);
+
+assert.sameValue(typeof datetime.toLocaleString("en", { dateStyle: "short" }), "string");
+assert.sameValue(typeof datetime.toLocaleString("en", { timeStyle: "short" }), "string");
+
+for (const [ option, value ] of conflictingOptions) {
+  assert.throws(TypeError, function() {
+    datetime.toLocaleString("en", { [option]: value, dateStyle: "short" });
+  }, `datetime.toLocaleString("en", { ${option}: "${value}",  dateStyle: "short" }) throws TypeError`);
+
+  assert.throws(TypeError, function() {
+    datetime.toLocaleString("en", { [option]: value, timeStyle: "short" });
+  }, `datetime.toLocaleString("en", { ${option}: "${value}",  timeStyle: "short" }) throws TypeError`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/options-undefined.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/options-undefined.js
new file mode 100644
index 0000000000..de5988529d
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/options-undefined.js
@@ -0,0 +1,21 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.tolocalestring
+description: Verify that undefined options are handled correctly.
+features: [Temporal]
+---*/
+
+const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321);
+const defaultFormatter = new Intl.DateTimeFormat('en', Object.create(null));
+const expected = defaultFormatter.format(datetime);
+
+const actualExplicit = datetime.toLocaleString('en', undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = datetime.toLocaleString('en');
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/resolved-time-zone.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/resolved-time-zone.js
new file mode 100644
index 0000000000..5c031fca3d
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/resolved-time-zone.js
@@ -0,0 +1,33 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.tolocalestring
+description: A time zone in resolvedOptions with a large offset still produces the correct string
+locale: [en]
+features: [Temporal]
+---*/
+
+// Using 24-hour clock to avoid format differences between Node 19 (which puts
+// "\u{202f}" before AM/PM) and previous versions that use regular spaces.
+const options = {
+  timeZone: "Pacific/Apia",
+  year: "numeric",
+  month: "numeric",
+  day: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  hourCycle: "h23"
+};
+
+const datetime1 = new Temporal.PlainDateTime(2021, 8, 4, 0, 30, 45, 123, 456, 789);
+const result1 = datetime1.toLocaleString("en", options);
+assert.sameValue(result1, "8/4/2021, 00:30:45");
+
+const datetime2 = new Temporal.PlainDateTime(2021, 8, 4, 23, 30, 45, 123, 456, 789);
+const result2 = datetime2.toLocaleString("en", options);
+assert.sameValue(result2, "8/4/2021, 23:30:45");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toLocaleString/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/calendarname-always.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/calendarname-always.js
new file mode 100644
index 0000000000..f927fd79f1
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/calendarname-always.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.tostring
+description: Show calendar when calendarName is "always"
+features: [Temporal]
+---*/
+
+const dt = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 0, 0, 0, 0, "gregory");
+
+assert.sameValue(
+  dt.toString({ calendarName: "always" }),
+  "1976-11-18T15:23:00[u-ca=gregory]",
+  "shows non-ISO calendar if calendarName = always"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/calendarname-auto.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/calendarname-auto.js
new file mode 100644
index 0000000000..e4b7ac4754
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/calendarname-auto.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.tostring
+description: Possibly display calendar when calendarName is "auto"
+features: [Temporal]
+---*/
+
+const dt = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 0, 0, 0, 0, "gregory");
+const expected = "1976-11-18T15:23:00[u-ca=gregory]";
+
+assert.sameValue(dt.toString(), expected, "shows non-ISO calendar by default (no arguments)");
+assert.sameValue(dt.toString({ calendarName: "auto" }), expected, "shows only non-ISO calendar if calendarName = auto");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/calendarname-never.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/calendarname-never.js
new file mode 100644
index 0000000000..0477747774
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/calendarname-never.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.tostring
+description: Do not show calendar (even non-ISO calendars) if calendarName = "never"
+features: [Temporal]
+---*/
+
+const dt = new Temporal.PlainDateTime(1976, 11, 18, 15, 23);
+
+assert.sameValue(
+  dt.withCalendar("gregory").toString({ calendarName: "never" }),
+  "1976-11-18T15:23:00",
+  "omits non-ISO calendar if calendarName = never"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toString/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toZonedDateTime/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toZonedDateTime/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toZonedDateTime/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toZonedDateTime/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toZonedDateTime/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toZonedDateTime/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toZonedDateTime/timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toZonedDateTime/timezone-string-datetime.js
new file mode 100644
index 0000000000..0a1fe0b201
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/toZonedDateTime/timezone-string-datetime.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.tozoneddatetime
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainDateTime(2000, 5, 2);
+
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+const result1 = instance.toZonedDateTime(timeZone);
+assert.sameValue(result1.timeZoneId, "America/Vancouver", "date-time + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+const result2 = instance.toZonedDateTime(timeZone);
+assert.sameValue(result2.timeZoneId, "America/Vancouver", "date-time + Z + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+const result3 = instance.toZonedDateTime(timeZone);
+assert.sameValue(result3.timeZoneId, "America/Vancouver", "date-time + offset + IANA annotation is the IANA time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/until/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/until/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/until/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/until/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/until/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..c42b700f6f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/until/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plaindatetime.prototype.until
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainDateTime(2000, 5, 2, 15, 0, 0, 0, 0, 0, "gregory");
+const base = { era: "ad", month: 5, day: 2, hour: 15, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.until({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.until({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/until/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/until/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/until/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar-noniso.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar-noniso.js
new file mode 100644
index 0000000000..09f952c922
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar-noniso.js
@@ -0,0 +1,57 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.withplaindate
+description: PlainDate calendar is preserved with ISO PDT
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+const cal = {
+  id: 'thisisnotiso',
+  era() { return "the era"; },
+  eraYear() { return 1909; },
+  toString() { return "this is a string"; },
+  year() { return 2008; },
+  month() { return 9; },
+  monthCode() { return "M09"; },
+  day() { return 6; },
+  dateAdd() {},
+  dateFromFields() {},
+  dateUntil() {},
+  dayOfWeek() {},
+  dayOfYear() {},
+  daysInMonth() {},
+  daysInWeek() {},
+  daysInYear() {},
+  fields() {},
+  inLeapYear() {},
+  mergeFields() {},
+  monthDayFromFields() {},
+  monthsInYear() {},
+  weekOfYear() {},
+  yearMonthFromFields() {},
+  yearOfWeek() {},
+};
+const pdt = new Temporal.PlainDateTime(1995, 12, 7, 3, 24, 30, 0, 0, 0);
+assert.sameValue(pdt.calendarId, "iso8601", "PlainDateTime with ISO calendar");
+const pd = new Temporal.PlainDate(2010, 11, 12, cal);
+const shifted = pdt.withPlainDate(pd);
+
+TemporalHelpers.assertPlainDateTime(
+  shifted,
+  2008, 9, "M09", 6, 3, 24, 30, 0, 0, 0,
+  "calendar is changed if receiver has ISO calendar (1)",
+  "the era",
+  1909
+);
+
+assert.sameValue(
+  shifted.getCalendar(),
+  cal,
+  "calendar is changed if receiver has ISO calendar (2)"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar-same-id.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar-same-id.js
new file mode 100644
index 0000000000..3d8d0f9dcb
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar-same-id.js
@@ -0,0 +1,80 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.withplaindate
+description: PlainDate calendar is preserved when both calendars have the same id
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+const cal1 = {
+  id: "this is a string",
+  toString() { return "this is a another string"; },
+  dateAdd() {},
+  dateFromFields() {},
+  dateUntil() {},
+  day() {},
+  dayOfWeek() {},
+  dayOfYear() {},
+  daysInMonth() {},
+  daysInWeek() {},
+  daysInYear() {},
+  fields() {},
+  inLeapYear() {},
+  mergeFields() {},
+  month() {},
+  monthCode() {},
+  monthDayFromFields() {},
+  monthsInYear() {},
+  weekOfYear() {},
+  year() {},
+  yearMonthFromFields() {},
+  yearOfWeek() {},
+};
+const cal2 = {
+  id: "this is a string",
+  era() { return "the era"; },
+  eraYear() { return 1909; },
+  toString() { return "thisisnotiso"; },
+  year() { return 2008; },
+  month() { return 9; },
+  monthCode() { return "M09"; },
+  day() { return 6; },
+  dateAdd() {},
+  dateFromFields() {},
+  dateUntil() {},
+  dayOfWeek() {},
+  dayOfYear() {},
+  daysInMonth() {},
+  daysInWeek() {},
+  daysInYear() {},
+  fields() {},
+  inLeapYear() {},
+  mergeFields() {},
+  monthDayFromFields() {},
+  monthsInYear() {},
+  weekOfYear() {},
+  yearMonthFromFields() {},
+  yearOfWeek() {},
+};
+const pdt = new Temporal.PlainDateTime(1995, 12, 7, 3, 24, 30, 0, 0, 0, cal1);
+const pd = new Temporal.PlainDate(2010, 11, 12, cal2);
+const shifted = pdt.withPlainDate(pd);
+
+TemporalHelpers.assertPlainDateTime(
+  shifted,
+  2008, 9, "M09", 6, 3, 24, 30, 0, 0, 0,
+  "calendar is changed with same id (1)",
+  "the era",
+  1909
+);
+
+assert.sameValue(
+  shifted.getCalendar(),
+  cal2,
+  "calendar is changed with same id (2)"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar-same-object.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar-same-object.js
new file mode 100644
index 0000000000..bdf08a0f7a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar-same-object.js
@@ -0,0 +1,64 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.withplaindate
+description: PlainDate calendar is preserved when both calendars are the same object
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+let calls = 0;
+const cal = {
+  get id() {
+    ++calls;
+    return "thisisnotiso";
+  },
+  era() { return "the era"; },
+  eraYear() { return 1909; },
+  toString() {
+    ++calls;
+    return "this is a string";
+  },
+  year() { return 2008; },
+  month() { return 9; },
+  monthCode() { return "M09"; },
+  day() { return 6; },
+  dateAdd() {},
+  dateFromFields() {},
+  dateUntil() {},
+  dayOfWeek() {},
+  dayOfYear() {},
+  daysInMonth() {},
+  daysInWeek() {},
+  daysInYear() {},
+  fields() {},
+  inLeapYear() {},
+  mergeFields() {},
+  monthDayFromFields() {},
+  monthsInYear() {},
+  weekOfYear() {},
+  yearMonthFromFields() {},
+  yearOfWeek() {},
+};
+const pdt = new Temporal.PlainDateTime(1995, 12, 7, 3, 24, 30, 0, 0, 0, cal);
+const pd = new Temporal.PlainDate(2010, 11, 12, cal);
+const shifted = pdt.withPlainDate(pd);
+
+TemporalHelpers.assertPlainDateTime(
+  shifted,
+  2008, 9, "M09", 6, 3, 24, 30, 0, 0, 0,
+  "calendar is unchanged with same calendars (1)",
+  "the era",
+  1909
+);
+
+assert.sameValue(
+  shifted.getCalendar(),
+  cal,
+  "calendar is unchanged with same calendars (2)"
+);
+assert.sameValue(calls, 0, "should not have called cal.toString() or accessed cal.id");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar.js
new file mode 100644
index 0000000000..3def15ddb9
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-plaindate-calendar.js
@@ -0,0 +1,57 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.withplaindate
+description: Original PDT calendar is preserved with ISO PlainDate
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+const cal = {
+  id: 'thisisnotiso',
+  era() { return "the era"; },
+  eraYear() { return 1909; },
+  toString() { return "this is a string"; },
+  year() { return 2008; },
+  month() { return 9; },
+  monthCode() { return "M09"; },
+  day() { return 6; },
+  dateAdd() {},
+  dateFromFields() {},
+  dateUntil() {},
+  dayOfWeek() {},
+  dayOfYear() {},
+  daysInMonth() {},
+  daysInWeek() {},
+  daysInYear() {},
+  fields() {},
+  inLeapYear() {},
+  mergeFields() {},
+  monthDayFromFields() {},
+  monthsInYear() {},
+  weekOfYear() {},
+  yearMonthFromFields() {},
+  yearOfWeek() {},
+};
+const pdt = new Temporal.PlainDateTime(1995, 12, 7, 3, 24, 30, 0, 0, 0, cal);
+const pd = new Temporal.PlainDate(2010, 11, 12);
+assert.sameValue(pd.calendarId, "iso8601", "PlainDate with ISO calendar");
+const shifted = pdt.withPlainDate(pd);
+
+TemporalHelpers.assertPlainDateTime(
+  shifted,
+  2008, 9, "M09", 6, 3, 24, 30, 0, 0, 0,
+  "calendar is unchanged if input has ISO calendar (1)",
+  "the era",
+  1909
+);
+
+assert.sameValue(
+  shifted.getCalendar(),
+  cal,
+  "calendar is unchanged if input has ISO calendar (2)"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-string-calendar.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-string-calendar.js
new file mode 100644
index 0000000000..b81895586a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-string-calendar.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.withplaindate
+description: non-ISO calendars are handled correctly
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const isopdt = new Temporal.PlainDateTime(1995, 12, 7, 3, 24, 30, 123, 456, 789);
+const gregorypdt = new Temporal.PlainDateTime(1995, 12, 7, 3, 24, 30, 123, 456, 789, "gregory");
+
+const result1 = isopdt.withPlainDate("2020-11-13[u-ca=gregory]");
+TemporalHelpers.assertPlainDateTime(result1, 2020, 11, "M11", 13, 3, 24, 30, 123, 456, 789,
+  "result1", "ce", 2020);
+assert.sameValue(result1.calendarId, "gregory", "non-ISO calendar in argument overrides ISO calendar in receiver");
+
+const result2 = gregorypdt.withPlainDate("2020-11-13[u-ca=iso8601]");
+TemporalHelpers.assertPlainDateTime(result2, 2020, 11, "M11", 13, 3, 24, 30, 123, 456, 789,
+  "result2", "ce", 2020);
+assert.sameValue(result2.calendarId, "gregory", "non-ISO calendar in receiver overrides ISO calendar in argument");
+
+assert.throws(RangeError, () => gregorypdt.withPlainDate("2020-11-13[u-ca=japanese]"),
+  "throws if both `this` and `other` have a non-ISO calendar");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-string-iso-calendar.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-string-iso-calendar.js
new file mode 100644
index 0000000000..643327b592
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/argument-string-iso-calendar.js
@@ -0,0 +1,55 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.withplaindate
+description: Original PDT calendar is preserved with ISO string
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+const cal = {
+  id: "thisisnotiso",
+  era() { return "the era"; },
+  eraYear() { return 1909; },
+  toString() { return "this is a string"; },
+  year() { return 2008; },
+  month() { return 9; },
+  monthCode() { return "M09"; },
+  day() { return 6; },
+  dateAdd() {},
+  dateFromFields() {},
+  dateUntil() {},
+  dayOfWeek() {},
+  dayOfYear() {},
+  daysInMonth() {},
+  daysInWeek() {},
+  daysInYear() {},
+  fields() {},
+  inLeapYear() {},
+  mergeFields() {},
+  monthDayFromFields() {},
+  monthsInYear() {},
+  weekOfYear() {},
+  yearMonthFromFields() {},
+  yearOfWeek() {},
+};
+const dt = new Temporal.PlainDateTime(1995, 12, 7, 3, 24, 30, 0, 0, 0, cal);
+const shifted = dt.withPlainDate("2010-11-12");
+
+TemporalHelpers.assertPlainDateTime(
+  shifted,
+  2008, 9, "M09", 6, 3, 24, 30, 0, 0, 0,
+  "calendar is unchanged if input has ISO calendar (1)",
+  "the era",
+  1909
+);
+
+assert.sameValue(
+  shifted.getCalendar(),
+  cal,
+  "calendar is unchanged if input has ISO calendar (2)"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/browser.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..9c2991eab5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plaindatetime.prototype.withplaindate
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainDateTime(2000, 5, 2, 15, 0, 0, 0, 0, 0, "gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.withPlainDate({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.withPlainDate({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/prototype/withPlainDate/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainDateTime/shell.js b/js/src/tests/test262/intl402/Temporal/PlainDateTime/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainDateTime/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/browser.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/browser.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/fields-missing-properties.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/fields-missing-properties.js
new file mode 100644
index 0000000000..1c4765e9db
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/fields-missing-properties.js
@@ -0,0 +1,15 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainmonthday.from
+description: >
+  Basic tests for PlainMonthDay.from(object) with missing properties for non-ISO
+  calendars
+features: [Temporal]
+---*/
+
+assert.throws(TypeError, () => Temporal.PlainMonthDay.from({ month: 11, day: 18, calendar: "gregory" }), "month, day with non-iso8601 calendar");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/fields-object.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/fields-object.js
new file mode 100644
index 0000000000..547f543246
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/fields-object.js
@@ -0,0 +1,36 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainmonthday.from
+description: Basic tests for PlainMonthDay.from(object) with non-ISO calendar
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const okTests = [
+  [{ monthCode: "M08", day: 1, calendar: "gregory" }, "gregory", "monthCode and non-ISO Gregorian string calendar"],
+  [{ monthCode: "M08", day: 1, calendar: "hebrew" }, "hebrew", "monthCode and non-ISO non-Gregorian string calendar"],
+  [{ monthCode: "M08", day: 1, calendar: Temporal.Calendar.from("gregory") }, "gregory", "monthCode and non-ISO Gregorian object calendar"],
+  [{ monthCode: "M08", day: 1, calendar: Temporal.Calendar.from("hebrew") }, "hebrew", "monthCode and non-ISO non-Gregorian object calendar"],
+];
+
+for (const [argument, expectedCalendar, description] of okTests) {
+  const plainMonthDay = Temporal.PlainMonthDay.from(argument);
+  TemporalHelpers.assertPlainMonthDay(plainMonthDay, "M08", 1, description);
+  assert.sameValue(plainMonthDay.calendarId, expectedCalendar, `resulting calendar is ${expectedCalendar}`);
+}
+
+const notOkTests = [
+  [{ month: 8, day: 1, calendar: "gregory" }, "month and non-ISO string calendar"],
+  [{ month: 8, day: 1, calendar: "hebrew" }, "month and non-ISO non-Gregorian string calendar"],
+  [{ month: 8, day: 1, calendar: Temporal.Calendar.from("gregory") }, "month and non-ISO Gregorian object calendar"],
+  [{ month: 8, day: 1, calendar: Temporal.Calendar.from("hebrew") }, "month and non-ISO non-Gregorian object calendar"],
+];
+
+for (const [argument, description] of notOkTests) {
+  assert.throws(TypeError, () => Temporal.PlainMonthDay.from(argument), description);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/reference-date-noniso-calendar.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/reference-date-noniso-calendar.js
new file mode 100644
index 0000000000..bf6eed6261
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/reference-date-noniso-calendar.js
@@ -0,0 +1,20 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainmonthday.from
+description: Verify that the result of ToTemporalMonthDay preserves year information for Non-ISO calendars.
+info: |
+    sec-temporal.plainmonthday.from step 3:
+      3. Return ? ToTemporalMonthDay(_item_, _options_).
+    sec-temporal-totemporalmonthday step 11.:
+      11. Set result to ? CreateTemporalMonthDay(_result_.[[Month]], _result_.[[Day]], _calendar_, _result_.[[Year]]).
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const pmd = Temporal.PlainMonthDay.from("2023-01-01[u-ca=hebrew]")
+TemporalHelpers.assertPlainMonthDay(pmd, "M04", 8); // 2023-01-01 corresponds to 8 Tevet in Hebrew Calendar.
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/shell.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/from/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/browser.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/equals/browser.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/equals/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/equals/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/equals/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/equals/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..3494b1644d
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/equals/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plainmonthday.prototype.equals
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainMonthDay(5, 2, "gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.equals({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.equals({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/equals/shell.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/equals/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/equals/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/shell.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/browser.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/calendar-mismatch.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/calendar-mismatch.js
new file mode 100644
index 0000000000..5cad007603
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/calendar-mismatch.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainmonthday.prototype.tolocalestring
+description: Calendar must match the locale calendar if not "iso8601"
+features: [Temporal, Intl-enumeration]
+---*/
+
+const localeCalendar = new Intl.DateTimeFormat().resolvedOptions().calendar;
+assert.notSameValue(localeCalendar, "iso8601", "no locale has the ISO calendar");
+
+const sameCalendarInstance = Temporal.PlainMonthDay.from({ monthCode: "M01", day: 1, calendar: localeCalendar });
+const result = sameCalendarInstance.toLocaleString();
+assert.sameValue(typeof result, "string", "toLocaleString() succeeds when instance has the same calendar as locale");
+
+// Pick a different calendar that is not ISO and not the locale's calendar
+const calendars = new Set(Intl.supportedValuesOf("calendar"));
+calendars.delete("iso8601");
+calendars.delete(localeCalendar);
+const differentCalendar = calendars.values().next().value;
+
+const differentCalendarInstance = Temporal.PlainMonthDay.from({ monthCode: "M01", day: 1, calendar: differentCalendar });
+assert.throws(RangeError, () => differentCalendarInstance.toLocaleString(), "calendar mismatch");
+
+const isoInstance = Temporal.PlainMonthDay.from({ monthCode: "M01", day: 1, calendar: "iso8601" });
+assert.throws(RangeError, () => isoInstance.toLocaleString(), "calendar mismatch even when instance has the ISO calendar")
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/locales-undefined.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/locales-undefined.js
new file mode 100644
index 0000000000..96f40e0394
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/locales-undefined.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainmonthday.prototype.tolocalestring
+description: Omitting the locales argument defaults to the DateTimeFormat default
+features: [Temporal]
+---*/
+
+const defaultFormatter = new Intl.DateTimeFormat([], Object.create(null));
+const { calendar } = defaultFormatter.resolvedOptions();
+const monthday = new Temporal.PlainMonthDay(5, 2, calendar);
+const expected = defaultFormatter.format(monthday);
+
+const actualExplicit = monthday.toLocaleString(undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = monthday.toLocaleString();
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/options-undefined.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/options-undefined.js
new file mode 100644
index 0000000000..e59afa1d33
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/options-undefined.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainmonthday.prototype.tolocalestring
+description: Verify that undefined options are handled correctly.
+features: [Temporal]
+---*/
+
+const defaultFormatter = new Intl.DateTimeFormat('en', Object.create(null));
+const { calendar } = defaultFormatter.resolvedOptions();
+const monthday = new Temporal.PlainMonthDay(5, 2, calendar);
+const expected = defaultFormatter.format(monthday);
+
+const actualExplicit = monthday.toLocaleString('en', undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = monthday.toLocaleString('en');
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/resolved-time-zone.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/resolved-time-zone.js
new file mode 100644
index 0000000000..bc66136c4f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/resolved-time-zone.js
@@ -0,0 +1,16 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainmonthday.prototype.tolocalestring
+description: A time zone in resolvedOptions with a large offset still produces the correct string
+locale: [en]
+features: [Temporal]
+---*/
+
+const monthDay = new Temporal.PlainMonthDay(8, 4, "gregory");
+const result = monthDay.toLocaleString("en", { timeZone: "Pacific/Apia" });
+assert.sameValue(result, "8/4");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/shell.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toPlainDate/browser.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toPlainDate/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toPlainDate/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toPlainDate/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toPlainDate/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..3adad5b50a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toPlainDate/infinity-throws-rangeerror.js
@@ -0,0 +1,23 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2020 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws a RangeError if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plainmonthday.prototype.toplaindate
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainMonthDay(5, 2, "gregory");
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.toPlainDate({ era: "ad", eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.toPlainDate({ era: "ad", eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toPlainDate/shell.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toPlainDate/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/toPlainDate/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/with/browser.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/with/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/with/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/with/fields-missing-properties.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/with/fields-missing-properties.js
new file mode 100644
index 0000000000..209ae9cd4f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/with/fields-missing-properties.js
@@ -0,0 +1,15 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainmonthday.prototype.with
+description: >
+  Basic tests for with(object) with missing properties for non-ISO calendars
+features: [Temporal]
+---*/
+
+const calendarMonthDay = Temporal.PlainMonthDay.from({ year: 2021, month: 1, day: 15, calendar: "gregory" });
+assert.throws(TypeError, () => calendarMonthDay.with({ month: 12 }), "nonIso8601MonthDay.with({month})");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/with/shell.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/with/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/prototype/with/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainMonthDay/shell.js b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainMonthDay/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/browser.js b/js/src/tests/test262/intl402/Temporal/PlainTime/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/browser.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/shell.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/browser.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/locales-undefined.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/locales-undefined.js
new file mode 100644
index 0000000000..43e8913bd5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/locales-undefined.js
@@ -0,0 +1,21 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaintime.prototype.tolocalestring
+description: Omitting the locales argument defaults to the DateTimeFormat default
+features: [Temporal]
+---*/
+
+const time = new Temporal.PlainTime(12, 34, 56, 987, 654, 321);
+const defaultFormatter = new Intl.DateTimeFormat([], Object.create(null));
+const expected = defaultFormatter.format(time);
+
+const actualExplicit = time.toLocaleString(undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = time.toLocaleString();
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/options-conflict.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/options-conflict.js
new file mode 100644
index 0000000000..31507d4c82
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/options-conflict.js
@@ -0,0 +1,40 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Kate Miháliková. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sup-temporal.plaintime.prototype.tolocalestring
+description: >
+    Conflicting properties of dateStyle must be rejected with a TypeError for the options argument
+info: |
+    Using sec-temporal-getdatetimeformatpattern:
+    GetDateTimeFormatPattern ( dateStyle, timeStyle, matcher, opt, dataLocaleData, hc )
+
+    1. If dateStyle is not undefined or timeStyle is not undefined, then
+      a. For each row in Table 7, except the header row, do
+        i. Let prop be the name given in the Property column of the row.
+        ii. Let p be opt.[[<prop>]].
+        iii. If p is not undefined, then
+          1. Throw a TypeError exception.
+features: [Temporal]
+---*/
+
+// Table 14 - Supported fields + example value for each field
+const conflictingOptions = [
+  [ "hour", "numeric" ],
+  [ "minute", "numeric" ],
+  [ "second", "numeric" ],
+  [ "dayPeriod", "short" ],
+  [ "fractionalSecondDigits", 3 ],
+];
+const time = new Temporal.PlainTime(12, 34, 56, 987, 654, 321);
+
+assert.sameValue(typeof time.toLocaleString("en", { timeStyle: "short" }), "string");
+
+for (const [ option, value ] of conflictingOptions) {
+  assert.throws(TypeError, function() {
+    time.toLocaleString("en", { [option]: value, timeStyle: "short" });
+  }, `time.toLocaleString("en", { ${option}: "${value}",  timeStyle: "short" }) throws TypeError`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/options-undefined.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/options-undefined.js
new file mode 100644
index 0000000000..adb1a6f614
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/options-undefined.js
@@ -0,0 +1,21 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaintime.prototype.tolocalestring
+description: Verify that undefined options are handled correctly.
+features: [Temporal]
+---*/
+
+const time = new Temporal.PlainTime(12, 34, 56, 987, 654, 321);
+const defaultFormatter = new Intl.DateTimeFormat('en', Object.create(null));
+const expected = defaultFormatter.format(time);
+
+const actualExplicit = time.toLocaleString('en', undefined);
+assert.sameValue(actualExplicit, expected, "default options are determined by Intl.DateTimeFormat");
+
+const actualImplicit = time.toLocaleString('en');
+assert.sameValue(actualImplicit, expected, "default options are determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/resolved-time-zone.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/resolved-time-zone.js
new file mode 100644
index 0000000000..5844e0210f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/resolved-time-zone.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaintime.prototype.tolocalestring
+description: A time zone in resolvedOptions with a large offset still produces the correct string
+locale: [en]
+features: [Temporal]
+---*/
+
+// Using 24-hour clock to avoid format differences between Node 19 (which puts
+// "\u{202f}" before AM/PM) and previous versions that use regular spaces.
+const options = {
+  timeZone: "Pacific/Apia",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  hourCycle: "h23"
+};
+
+const time1 = new Temporal.PlainTime(0, 30, 45, 123, 456, 789);
+const result1 = time1.toLocaleString("en", options);
+assert.sameValue(result1, "00:30:45");
+
+const time2 = new Temporal.PlainTime(23, 30, 45, 123, 456, 789);
+const result2 = time2.toLocaleString("en", options);
+assert.sameValue(result2, "23:30:45");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/shell.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toLocaleString/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toPlainDateTime/browser.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toPlainDateTime/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toPlainDateTime/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toPlainDateTime/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toPlainDateTime/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..359d5f058a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toPlainDateTime/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plaintime.prototype.toplaindatetime
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainTime(15);
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.toPlainDateTime({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.toPlainDateTime({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toPlainDateTime/shell.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toPlainDateTime/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toPlainDateTime/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/browser.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/plaindate-infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/plaindate-infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..c7423da29c
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/plaindate-infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plaintime.prototype.tozoneddatetime
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainTime(15);
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.toZonedDateTime({ timeZone: "UTC", plainDate: { ...base, eraYear: inf } }), `eraYear property cannot be ${inf} in plainDate`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.toZonedDateTime({ timeZone: "UTC", plainDate: { ...base, eraYear: obj } }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/shell.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/timezone-string-datetime.js
new file mode 100644
index 0000000000..51293aa08c
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/prototype/toZonedDateTime/timezone-string-datetime.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaintime.prototype.tozoneddatetime
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainTime();
+
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+const result1 = instance.toZonedDateTime({ plainDate: new Temporal.PlainDate(2000, 5, 2), timeZone });
+assert.sameValue(result1.timeZoneId, "America/Vancouver", "date-time + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+const result2 = instance.toZonedDateTime({ plainDate: new Temporal.PlainDate(2000, 5, 2), timeZone });
+assert.sameValue(result2.timeZoneId, "America/Vancouver", "date-time + Z + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+const result3 = instance.toZonedDateTime({ plainDate: new Temporal.PlainDate(2000, 5, 2), timeZone });
+assert.sameValue(result3.timeZoneId, "America/Vancouver", "date-time + offset + IANA annotation is the IANA time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainTime/shell.js b/js/src/tests/test262/intl402/Temporal/PlainTime/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainTime/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/browser.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/compare/browser.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/compare/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/compare/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/compare/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/compare/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..4ee79a26e6
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/compare/infinity-throws-rangeerror.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if any value in a property bag for either argument is Infinity or -Infinity
+esid: sec-temporal.plainyearmonth.compare
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const other = new Temporal.PlainYearMonth(2000, 5, "gregory");
+const base = { era: "ad", month: 5, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => Temporal.PlainYearMonth.compare({ ...base, eraYear: inf }, other), `eraYear property cannot be ${inf}`);
+
+  assert.throws(RangeError, () => Temporal.PlainYearMonth.compare(other, { ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls1 = [];
+  const obj1 = TemporalHelpers.toPrimitiveObserver(calls1, inf, "eraYear");
+  assert.throws(RangeError, () => Temporal.PlainYearMonth.compare({ ...base, eraYear: obj1 }, other));
+  assert.compareArray(calls1, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+
+  const calls2 = [];
+  const obj2 = TemporalHelpers.toPrimitiveObserver(calls2, inf, "eraYear");
+  assert.throws(RangeError, () => Temporal.PlainYearMonth.compare(other, { ...base, eraYear: obj2 }));
+  assert.compareArray(calls2, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/compare/shell.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/compare/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/compare/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/argument-object.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/argument-object.js
new file mode 100644
index 0000000000..a8bf0eb747
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/argument-object.js
@@ -0,0 +1,20 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainyearmonth.from
+description: An object argument
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const monthDayItem = { calendar: "gregory", era: "ce", eraYear: 2019, month: 11, get day() { throw new Test262Error("should not read the day property") } };
+TemporalHelpers.assertPlainYearMonth(Temporal.PlainYearMonth.from(monthDayItem),
+  2019, 11, "M11", "month with day", "ce", 2019);
+
+const monthCodeDayItem = { calendar: "gregory", era: "ce", eraYear: 2019, monthCode: "M11", get day() { throw new Test262Error("should not read the day property") } };
+TemporalHelpers.assertPlainYearMonth(Temporal.PlainYearMonth.from(monthCodeDayItem),
+  2019, 11, "M11", "monthCode with day", "ce", 2019);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/browser.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..54792dbce0
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/infinity-throws-rangeerror.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plainyearmonth.from
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const base = { era: "ad", month: 5, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  ["constrain", "reject"].forEach((overflow) => {
+    assert.throws(RangeError, () => Temporal.PlainYearMonth.from({ ...base, eraYear: inf }, { overflow }), `eraYear property cannot be ${inf} (overflow ${overflow}`);
+
+    const calls = [];
+    const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+    assert.throws(RangeError, () => Temporal.PlainYearMonth.from({ ...base, eraYear: obj }, { overflow }));
+    assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/shell.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/from/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/browser.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/equals/browser.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/equals/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/equals/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/equals/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/equals/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..00e3922f1d
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/equals/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plainyearmonth.prototype.equals
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainYearMonth(2000, 5, "gregory");
+const base = { era: "ad", month: 5, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.equals({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.equals({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/equals/shell.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/equals/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/equals/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/branding.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/branding.js
new file mode 100644
index 0000000000..250e5eaee9
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/branding.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plainyearmonth.prototype.era
+description: Throw a TypeError if the receiver is invalid
+features: [Symbol, Temporal]
+---*/
+
+const era = Object.getOwnPropertyDescriptor(Temporal.PlainYearMonth.prototype, "era").get;
+
+assert.sameValue(typeof era, "function");
+
+assert.throws(TypeError, () => era.call(undefined), "undefined");
+assert.throws(TypeError, () => era.call(null), "null");
+assert.throws(TypeError, () => era.call(true), "true");
+assert.throws(TypeError, () => era.call(""), "empty string");
+assert.throws(TypeError, () => era.call(Symbol()), "symbol");
+assert.throws(TypeError, () => era.call(1), "1");
+assert.throws(TypeError, () => era.call({}), "plain object");
+assert.throws(TypeError, () => era.call(Temporal.PlainYearMonth), "Temporal.PlainYearMonth");
+assert.throws(TypeError, () => era.call(Temporal.PlainYearMonth.prototype), "Temporal.PlainYearMonth.prototype");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/browser.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/prop-desc.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/prop-desc.js
new file mode 100644
index 0000000000..90188ed459
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/prop-desc.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plainyearmonth.prototype.era
+description: The "era" property of Temporal.PlainYearMonth.prototype
+features: [Temporal]
+---*/
+
+const descriptor = Object.getOwnPropertyDescriptor(Temporal.PlainYearMonth.prototype, "era");
+assert.sameValue(typeof descriptor.get, "function");
+assert.sameValue(descriptor.set, undefined);
+assert.sameValue(descriptor.enumerable, false);
+assert.sameValue(descriptor.configurable, true);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/shell.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/validate-calendar-value.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/validate-calendar-value.js
new file mode 100644
index 0000000000..f49c5548de
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/era/validate-calendar-value.js
@@ -0,0 +1,54 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plainyearmonth.prototype.era
+description: Validate result returned from calendar era() method
+features: [Temporal]
+---*/
+
+const badResults = [
+  [null, TypeError],
+  [false, TypeError],
+  [Infinity, TypeError],
+  [-Infinity, TypeError],
+  [NaN, TypeError],
+  [-7, TypeError],
+  [-0.1, TypeError],
+  [Symbol("foo"), TypeError],
+  [7n, TypeError],
+  [{}, TypeError],
+  [true, TypeError],
+  [7.1, TypeError],
+  [{valueOf() { return "7"; }}, TypeError],
+];
+
+badResults.forEach(([result, error]) => {
+  const calendar = new class extends Temporal.Calendar {
+    era() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainYearMonth(1981, 12, calendar);
+  assert.throws(error, () => instance.era, `${typeof result} ${String(result)} not converted to string`);
+});
+
+const preservedResults = [
+  undefined,
+  "string",
+  "7",
+  "7.5",
+];
+
+preservedResults.forEach(result => {
+  const calendar = new class extends Temporal.Calendar {
+    era() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainYearMonth(1981, 12, calendar);
+  assert.sameValue(instance.era, result, `${typeof result} ${String(result)} preserved`);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/branding.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/branding.js
new file mode 100644
index 0000000000..e847e93a43
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/branding.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plainyearmonth.prototype.erayear
+description: Throw a TypeError if the receiver is invalid
+features: [Symbol, Temporal]
+---*/
+
+const eraYear = Object.getOwnPropertyDescriptor(Temporal.PlainYearMonth.prototype, "eraYear").get;
+
+assert.sameValue(typeof eraYear, "function");
+
+assert.throws(TypeError, () => eraYear.call(undefined), "undefined");
+assert.throws(TypeError, () => eraYear.call(null), "null");
+assert.throws(TypeError, () => eraYear.call(true), "true");
+assert.throws(TypeError, () => eraYear.call(""), "empty string");
+assert.throws(TypeError, () => eraYear.call(Symbol()), "symbol");
+assert.throws(TypeError, () => eraYear.call(1), "1");
+assert.throws(TypeError, () => eraYear.call({}), "plain object");
+assert.throws(TypeError, () => eraYear.call(Temporal.PlainYearMonth), "Temporal.PlainYearMonth");
+assert.throws(TypeError, () => eraYear.call(Temporal.PlainYearMonth.prototype), "Temporal.PlainYearMonth.prototype");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/browser.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/prop-desc.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/prop-desc.js
new file mode 100644
index 0000000000..5ab24b9593
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/prop-desc.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plainyearmonth.prototype.erayear
+description: The "eraYear" property of Temporal.PlainYearMonth.prototype
+features: [Temporal]
+---*/
+
+const descriptor = Object.getOwnPropertyDescriptor(Temporal.PlainYearMonth.prototype, "eraYear");
+assert.sameValue(typeof descriptor.get, "function");
+assert.sameValue(descriptor.set, undefined);
+assert.sameValue(descriptor.enumerable, false);
+assert.sameValue(descriptor.configurable, true);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/shell.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/validate-calendar-value.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/validate-calendar-value.js
new file mode 100644
index 0000000000..296a9f3e15
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/eraYear/validate-calendar-value.js
@@ -0,0 +1,54 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.plainyearmonth.prototype.erayear
+description: Validate result returned from calendar eraYear() method
+features: [Temporal]
+---*/
+
+const badResults = [
+  [null, TypeError],
+  [false, TypeError],
+  [Infinity, RangeError],
+  [-Infinity, RangeError],
+  [NaN, RangeError],
+  [-0.1, RangeError],
+  ["string", TypeError],
+  [Symbol("foo"), TypeError],
+  [7n, TypeError],
+  [{}, TypeError],
+  [true, TypeError],
+  [7.1, RangeError],
+  ["7", TypeError],
+  ["7.5", TypeError],
+  [{valueOf() { return 7; }}, TypeError],
+];
+
+badResults.forEach(([result, error]) => {
+  const calendar = new class extends Temporal.Calendar {
+    eraYear() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainYearMonth(1981, 12, calendar);
+  assert.throws(error, () => instance.eraYear, `${typeof result} ${String(result)} not converted to integer`);
+});
+
+const preservedResults = [
+  undefined,
+  -7,
+];
+
+preservedResults.forEach(result => {
+  const calendar = new class extends Temporal.Calendar {
+    eraYear() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.PlainYearMonth(1981, 12, calendar);
+  assert.sameValue(instance.eraYear, result, `${typeof result} ${String(result)} preserved`);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/shell.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/since/browser.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/since/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/since/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/since/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/since/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..f4b81344f4
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/since/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plainyearmonth.prototype.since
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainYearMonth(2000, 5, "gregory");
+const base = { era: "ad", month: 5, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.since({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.since({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/since/shell.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/since/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/since/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/browser.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/calendar-mismatch.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/calendar-mismatch.js
new file mode 100644
index 0000000000..7c98e589a0
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/calendar-mismatch.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainyearmonth.prototype.tolocalestring
+description: Calendar must match the locale calendar
+features: [Temporal, Intl-enumeration]
+---*/
+
+const localeCalendar = new Intl.DateTimeFormat().resolvedOptions().calendar;
+assert.notSameValue(localeCalendar, "iso8601", "no locale has the ISO calendar");
+
+const sameCalendarInstance = new Temporal.PlainDate(2000, 1, 1, localeCalendar).toPlainYearMonth();
+const result = sameCalendarInstance.toLocaleString();
+assert.sameValue(typeof result, "string", "toLocaleString() succeeds when instance has the same calendar as locale");
+
+// Pick a different calendar that is not ISO and not the locale's calendar
+const calendars = new Set(Intl.supportedValuesOf("calendar"));
+calendars.delete("iso8601");
+calendars.delete(localeCalendar);
+const differentCalendar = calendars.values().next().value;
+
+const differentCalendarInstance = new Temporal.PlainDate(2000, 1, 1, differentCalendar).toPlainYearMonth();
+assert.throws(RangeError, () => differentCalendarInstance.toLocaleString(), "calendar mismatch");
+
+const isoInstance = new Temporal.PlainDate(2000, 1, 1, "iso8601").toPlainYearMonth();
+assert.throws(RangeError, () => isoInstance.toLocaleString(), "calendar mismatch even when instance has the ISO calendar")
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/locales-undefined.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/locales-undefined.js
new file mode 100644
index 0000000000..be3ff739ca
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/locales-undefined.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainyearmonth.prototype.tolocalestring
+description: Omitting the locales argument defaults to the DateTimeFormat default
+features: [Temporal]
+---*/
+
+const defaultFormatter = new Intl.DateTimeFormat([], Object.create(null));
+const { calendar } = defaultFormatter.resolvedOptions();
+const yearmonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+const expected = defaultFormatter.format(yearmonth);
+
+const actualExplicit = yearmonth.toLocaleString(undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = yearmonth.toLocaleString();
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/options-undefined.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/options-undefined.js
new file mode 100644
index 0000000000..fa036ddc6f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/options-undefined.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainyearmonth.prototype.tolocalestring
+description: Verify that undefined options are handled correctly.
+features: [Temporal]
+---*/
+
+const defaultFormatter = new Intl.DateTimeFormat('en', Object.create(null));
+const { calendar } = defaultFormatter.resolvedOptions();
+const yearmonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+const expected = defaultFormatter.format(yearmonth);
+
+const actualExplicit = yearmonth.toLocaleString('en', undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = yearmonth.toLocaleString('en');
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/resolved-time-zone.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/resolved-time-zone.js
new file mode 100644
index 0000000000..1dc10ccf38
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/resolved-time-zone.js
@@ -0,0 +1,16 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainyearmonth.prototype.tolocalestring
+description: A time zone in resolvedOptions with a large offset still produces the correct string
+locale: [en]
+features: [Temporal]
+---*/
+
+const month = new Temporal.PlainYearMonth(2021, 8, "gregory");
+const result = month.toLocaleString("en", { timeZone: "Pacific/Apia" });
+assert.sameValue(result, "8/2021");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/shell.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/until/browser.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/until/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/until/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/until/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/until/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..5e909a3f0c
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/until/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.plainyearmonth.prototype.until
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.PlainYearMonth(2000, 5, "gregory");
+const base = { era: "ad", month: 5, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.until({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.until({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/until/shell.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/until/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/prototype/until/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/PlainYearMonth/shell.js b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/PlainYearMonth/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/basic.js b/js/src/tests/test262/intl402/Temporal/TimeZone/basic.js
new file mode 100644
index 0000000000..2344d05187
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/basic.js
@@ -0,0 +1,32 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: Basic tests for the Temporal.TimeZone constructor.
+features: [Temporal]
+---*/
+
+const valid = [
+  ["Europe/Vienna"],
+  ["America/New_York"],
+  ["Africa/CAIRO", "Africa/Cairo"],
+  ["africa/cairo", "Africa/Cairo"],
+  ["Asia/Ulaanbaatar"],
+  ["Asia/Ulan_Bator"],
+  ["UTC"],
+  ["GMT"]
+];
+for (const [zone, id = zone] of valid) {
+  const result = new Temporal.TimeZone(zone);
+  assert.sameValue(typeof result, "object", `object should be created for ${zone}`);
+  assert.sameValue(result.id, id, `id for ${zone} should be ${id}`);
+}
+
+const invalid = ["+00:01.1", "-01.1"];
+for (const zone of invalid) {
+  assert.throws(RangeError, () => new Temporal.TimeZone(zone), `should throw for ${zone}`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/browser.js b/js/src/tests/test262/intl402/Temporal/TimeZone/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/etc-timezone.js b/js/src/tests/test262/intl402/Temporal/TimeZone/etc-timezone.js
new file mode 100644
index 0000000000..7703f6b58f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/etc-timezone.js
@@ -0,0 +1,69 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: Some Etc/GMT{+/-}{0}N timezones are valid, but not all
+features: [Temporal]
+---*/
+
+// "Etc/GMT-0" through "Etc/GMT-14" are OK
+
+[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14].forEach((n) => {
+  let tz = "Etc/GMT-" + n;
+  let instance = new Temporal.TimeZone(tz);
+  assert.sameValue(
+    instance.toString(),
+    tz,
+    tz + " is a valid timezone"
+  );
+});
+
+let gmtMinus24TZ = "Etc/GMT-24";
+assert.throws(
+  RangeError,
+  () => { new Temporal.TimeZone(gmtMinus24TZ); },
+  gmtMinus24TZ + " is an invalid timezone"
+);
+
+// "Etc/GMT-0N" is not OK (1 ≤ N ≤ 9)
+[1,2,3,4,5,6,7,8,9].forEach((n) => {
+  let tz = "Etc/GMT-0" + n;
+  assert.throws(
+    RangeError,
+    () => { new Temporal.TimeZone(tz); },
+    tz + " is an invalid timezone"
+  );
+});
+
+// "Etc/GMT+0N" is not OK (0 ≤ N ≤ 9)
+[0,1,2,3,4,5,6,7,8,9].forEach((n) => {
+  let tz = "Etc/GMT+0" + n;
+  assert.throws(
+    RangeError,
+    () => { new Temporal.TimeZone(tz); },
+    tz + " is an invalid timezone"
+    );
+});
+
+// Etc/GMT+0" through "Etc/GMT+12" are OK
+
+[0,1,2,3,4,5,6,7,8,9,10,11,12].forEach((n) => {
+  let tz = "Etc/GMT+" + n;
+  let instance = new Temporal.TimeZone(tz);
+  assert.sameValue(
+    instance.toString(),
+    tz,
+    tz + " is a valid timezone"
+  );
+});
+
+let gmtPlus24TZ = "Etc/GMT+24";
+assert.throws(
+  RangeError,
+  () => { new Temporal.TimeZone(gmtPlus24TZ); },
+  gmtPlus24TZ + " is an invalid timezone"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/from/argument-object.js b/js/src/tests/test262/intl402/Temporal/TimeZone/from/argument-object.js
new file mode 100644
index 0000000000..64c3264f09
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/from/argument-object.js
@@ -0,0 +1,39 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2020 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.from
+description: An object is returned unchanged
+features: [Temporal]
+---*/
+
+class CustomTimeZone extends Temporal.TimeZone {}
+
+const objects = [
+  new Temporal.TimeZone("Europe/Madrid"),
+  new CustomTimeZone("Africa/Accra"),
+];
+
+const thisValues = [
+  Temporal.TimeZone,
+  CustomTimeZone,
+  {},
+  null,
+  undefined,
+  7,
+];
+
+for (const thisValue of thisValues) {
+  for (const object of objects) {
+    const result = Temporal.TimeZone.from.call(thisValue, object);
+    assert.sameValue(result, object);
+  }
+
+  const zdt = new Temporal.ZonedDateTime(0n, "Africa/Cairo");
+  const fromZdt = Temporal.TimeZone.from.call(thisValue, zdt);
+  assert.notSameValue(fromZdt, zdt.getTimeZone(), "from() creates a new object for a string slot value");
+  assert.sameValue(fromZdt.id, "Africa/Cairo");
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/from/argument-valid.js b/js/src/tests/test262/intl402/Temporal/TimeZone/from/argument-valid.js
new file mode 100644
index 0000000000..340be95d3b
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/from/argument-valid.js
@@ -0,0 +1,33 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2020 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.from
+description: Built-in time zones are parsed correctly out of valid strings
+features: [Temporal]
+---*/
+
+const valids = [
+  ["Africa/Bissau"],
+  ["America/Belem"],
+  ["Europe/Vienna"],
+  ["America/New_York"],
+  ["Africa/CAIRO", "Africa/Cairo"],
+  ["Asia/Ulan_Bator"],
+  ["GMT"],
+  ["etc/gmt", "Etc/GMT"],
+  ["1994-11-05T08:15:30-05:00[America/New_York]", "America/New_York"],
+  ["1994-11-05T08:15:30-05[America/New_York]", "America/New_York"],
+  ["1994-11-05T08:15:30\u221205:00[America/New_York]", "America/New_York"],
+  ["1994-11-05T08:15:30\u221205[America/New_York]", "America/New_York"],
+];
+
+for (const [valid, canonical = valid] of valids) {
+  const result = Temporal.TimeZone.from(valid);
+  assert.sameValue(Object.getPrototypeOf(result), Temporal.TimeZone.prototype);
+  assert.sameValue(result.id, canonical);
+  assert.sameValue(result.toString(), canonical);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/from/browser.js b/js/src/tests/test262/intl402/Temporal/TimeZone/from/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/from/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/from/etc-timezone.js b/js/src/tests/test262/intl402/Temporal/TimeZone/from/etc-timezone.js
new file mode 100644
index 0000000000..b29088007e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/from/etc-timezone.js
@@ -0,0 +1,69 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.from
+description: Some Etc/GMT{+/-}{0}N timezones are valid, but not all
+features: [Temporal]
+---*/
+
+// "Etc/GMT-0" through "Etc/GMT-14" are OK
+
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14].forEach((n) => {
+  const tz = "Etc/GMT-" + n;
+  const instance = Temporal.TimeZone.from(tz);
+  assert.sameValue(
+    instance.toString(),
+    tz,
+    tz + " is a valid timezone"
+  );
+});
+
+const gmtMinus24TZ = "Etc/GMT-24";
+assert.throws(
+  RangeError,
+  () => Temporal.TimeZone.from(gmtMinus24TZ),
+  gmtMinus24TZ + " is an invalid timezone"
+);
+
+// "Etc/GMT-0N" is not OK (1 ≤ N ≤ 9)
+[1, 2, 3, 4, 5, 6, 7, 8, 9].forEach((n) => {
+  const tz = "Etc/GMT-0" + n;
+  assert.throws(
+    RangeError,
+    () => Temporal.TimeZone.from(tz),
+    tz + " is an invalid timezone"
+  );
+});
+
+// "Etc/GMT+0N" is not OK (0 ≤ N ≤ 9)
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach((n) => {
+  const tz = "Etc/GMT+0" + n;
+  assert.throws(
+    RangeError,
+    () => Temporal.TimeZone.from(tz),
+    tz + " is an invalid timezone"
+    );
+});
+
+// "Etc/GMT+0" through "Etc/GMT+12" are OK
+
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].forEach((n) => {
+  const tz = "Etc/GMT+" + n;
+  const instance = Temporal.TimeZone.from(tz);
+  assert.sameValue(
+    instance.toString(),
+    tz,
+    tz + " is a valid timezone"
+  );
+});
+
+const gmtPlus24TZ = "Etc/GMT+24";
+assert.throws(
+  RangeError,
+  () => Temporal.TimeZone.from(gmtPlus24TZ),
+  gmtPlus24TZ + " is an invalid timezone"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/from/iana-legacy-names.js b/js/src/tests/test262/intl402/Temporal/TimeZone/from/iana-legacy-names.js
new file mode 100644
index 0000000000..d04aa99656
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/from/iana-legacy-names.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: IANA legacy names must be supported
+features: [Temporal]
+---*/
+
+const legacyNames = [
+  "Etc/GMT0",
+  "GMT0",
+  "GMT-0",
+  "GMT+0",
+  "EST5EDT", 
+  "CST6CDT", 
+  "MST7MDT", 
+  "PST8PDT"
+];
+
+legacyNames.forEach((arg) => {
+  const tz = Temporal.TimeZone.from(arg);
+  assert.sameValue(tz.toString(), arg, `"${arg}" does not match "${tz.toString()}" time zone identifier`);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/from/shell.js b/js/src/tests/test262/intl402/Temporal/TimeZone/from/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/from/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/from/timezone-case-insensitive.js b/js/src/tests/test262/intl402/Temporal/TimeZone/from/timezone-case-insensitive.js
new file mode 100644
index 0000000000..52a86b6497
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/from/timezone-case-insensitive.js
@@ -0,0 +1,628 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.from
+description: Time zone identifiers are case-normalized
+features: [Temporal]
+---*/
+
+const timeZoneIdentifiers = [
+  // IANA TZDB Zone names
+  'Africa/Abidjan',
+  'Africa/Algiers',
+  'Africa/Bissau',
+  'Africa/Cairo',
+  'Africa/Casablanca',
+  'Africa/Ceuta',
+  'Africa/El_Aaiun',
+  'Africa/Johannesburg',
+  'Africa/Juba',
+  'Africa/Khartoum',
+  'Africa/Lagos',
+  'Africa/Maputo',
+  'Africa/Monrovia',
+  'Africa/Nairobi',
+  'Africa/Ndjamena',
+  'Africa/Sao_Tome',
+  'Africa/Tripoli',
+  'Africa/Tunis',
+  'Africa/Windhoek',
+  'America/Adak',
+  'America/Anchorage',
+  'America/Araguaina',
+  'America/Argentina/Buenos_Aires',
+  'America/Argentina/Catamarca',
+  'America/Argentina/Cordoba',
+  'America/Argentina/Jujuy',
+  'America/Argentina/La_Rioja',
+  'America/Argentina/Mendoza',
+  'America/Argentina/Rio_Gallegos',
+  'America/Argentina/Salta',
+  'America/Argentina/San_Juan',
+  'America/Argentina/San_Luis',
+  'America/Argentina/Tucuman',
+  'America/Argentina/Ushuaia',
+  'America/Asuncion',
+  'America/Bahia',
+  'America/Bahia_Banderas',
+  'America/Barbados',
+  'America/Belem',
+  'America/Belize',
+  'America/Boa_Vista',
+  'America/Bogota',
+  'America/Boise',
+  'America/Cambridge_Bay',
+  'America/Campo_Grande',
+  'America/Cancun',
+  'America/Caracas',
+  'America/Cayenne',
+  'America/Chicago',
+  'America/Chihuahua',
+  // 'America/Ciudad_Juarez' // uncomment after Node supports this ID added in TZDB 2022g
+  'America/Costa_Rica',
+  'America/Cuiaba',
+  'America/Danmarkshavn',
+  'America/Dawson',
+  'America/Dawson_Creek',
+  'America/Denver',
+  'America/Detroit',
+  'America/Edmonton',
+  'America/Eirunepe',
+  'America/El_Salvador',
+  'America/Fort_Nelson',
+  'America/Fortaleza',
+  'America/Glace_Bay',
+  'America/Goose_Bay',
+  'America/Grand_Turk',
+  'America/Guatemala',
+  'America/Guayaquil',
+  'America/Guyana',
+  'America/Halifax',
+  'America/Havana',
+  'America/Hermosillo',
+  'America/Indiana/Indianapolis',
+  'America/Indiana/Knox',
+  'America/Indiana/Marengo',
+  'America/Indiana/Petersburg',
+  'America/Indiana/Tell_City',
+  'America/Indiana/Vevay',
+  'America/Indiana/Vincennes',
+  'America/Indiana/Winamac',
+  'America/Inuvik',
+  'America/Iqaluit',
+  'America/Jamaica',
+  'America/Juneau',
+  'America/Kentucky/Louisville',
+  'America/Kentucky/Monticello',
+  'America/La_Paz',
+  'America/Lima',
+  'America/Los_Angeles',
+  'America/Maceio',
+  'America/Managua',
+  'America/Manaus',
+  'America/Martinique',
+  'America/Matamoros',
+  'America/Mazatlan',
+  'America/Menominee',
+  'America/Merida',
+  'America/Metlakatla',
+  'America/Mexico_City',
+  'America/Miquelon',
+  'America/Moncton',
+  'America/Monterrey',
+  'America/Montevideo',
+  'America/New_York',
+  'America/Nome',
+  'America/Noronha',
+  'America/North_Dakota/Beulah',
+  'America/North_Dakota/Center',
+  'America/North_Dakota/New_Salem',
+  'America/Nuuk',
+  'America/Ojinaga',
+  'America/Panama',
+  'America/Paramaribo',
+  'America/Phoenix',
+  'America/Port-au-Prince',
+  'America/Porto_Velho',
+  'America/Puerto_Rico',
+  'America/Punta_Arenas',
+  'America/Rankin_Inlet',
+  'America/Recife',
+  'America/Regina',
+  'America/Resolute',
+  'America/Rio_Branco',
+  'America/Santarem',
+  'America/Santiago',
+  'America/Santo_Domingo',
+  'America/Sao_Paulo',
+  'America/Scoresbysund',
+  'America/Sitka',
+  'America/St_Johns',
+  'America/Swift_Current',
+  'America/Tegucigalpa',
+  'America/Thule',
+  'America/Tijuana',
+  'America/Toronto',
+  'America/Vancouver',
+  'America/Whitehorse',
+  'America/Winnipeg',
+  'America/Yakutat',
+  'America/Yellowknife',
+  'Antarctica/Casey',
+  'Antarctica/Davis',
+  'Antarctica/Macquarie',
+  'Antarctica/Mawson',
+  'Antarctica/Palmer',
+  'Antarctica/Rothera',
+  'Antarctica/Troll',
+  'Asia/Almaty',
+  'Asia/Amman',
+  'Asia/Anadyr',
+  'Asia/Aqtau',
+  'Asia/Aqtobe',
+  'Asia/Ashgabat',
+  'Asia/Atyrau',
+  'Asia/Baghdad',
+  'Asia/Baku',
+  'Asia/Bangkok',
+  'Asia/Barnaul',
+  'Asia/Beirut',
+  'Asia/Bishkek',
+  'Asia/Chita',
+  'Asia/Choibalsan',
+  'Asia/Colombo',
+  'Asia/Damascus',
+  'Asia/Dhaka',
+  'Asia/Dili',
+  'Asia/Dubai',
+  'Asia/Dushanbe',
+  'Asia/Famagusta',
+  'Asia/Gaza',
+  'Asia/Hebron',
+  'Asia/Ho_Chi_Minh',
+  'Asia/Hong_Kong',
+  'Asia/Hovd',
+  'Asia/Irkutsk',
+  'Asia/Jakarta',
+  'Asia/Jayapura',
+  'Asia/Jerusalem',
+  'Asia/Kabul',
+  'Asia/Kamchatka',
+  'Asia/Karachi',
+  'Asia/Kathmandu',
+  'Asia/Khandyga',
+  'Asia/Kolkata',
+  'Asia/Krasnoyarsk',
+  'Asia/Kuching',
+  'Asia/Macau',
+  'Asia/Magadan',
+  'Asia/Makassar',
+  'Asia/Manila',
+  'Asia/Nicosia',
+  'Asia/Novokuznetsk',
+  'Asia/Novosibirsk',
+  'Asia/Omsk',
+  'Asia/Oral',
+  'Asia/Pontianak',
+  'Asia/Pyongyang',
+  'Asia/Qatar',
+  'Asia/Qostanay',
+  'Asia/Qyzylorda',
+  'Asia/Riyadh',
+  'Asia/Sakhalin',
+  'Asia/Samarkand',
+  'Asia/Seoul',
+  'Asia/Shanghai',
+  'Asia/Singapore',
+  'Asia/Srednekolymsk',
+  'Asia/Taipei',
+  'Asia/Tashkent',
+  'Asia/Tbilisi',
+  'Asia/Tehran',
+  'Asia/Thimphu',
+  'Asia/Tokyo',
+  'Asia/Tomsk',
+  'Asia/Ulaanbaatar',
+  'Asia/Urumqi',
+  'Asia/Ust-Nera',
+  'Asia/Vladivostok',
+  'Asia/Yakutsk',
+  'Asia/Yangon',
+  'Asia/Yekaterinburg',
+  'Asia/Yerevan',
+  'Atlantic/Azores',
+  'Atlantic/Bermuda',
+  'Atlantic/Canary',
+  'Atlantic/Cape_Verde',
+  'Atlantic/Faroe',
+  'Atlantic/Madeira',
+  'Atlantic/South_Georgia',
+  'Atlantic/Stanley',
+  'Australia/Adelaide',
+  'Australia/Brisbane',
+  'Australia/Broken_Hill',
+  'Australia/Darwin',
+  'Australia/Eucla',
+  'Australia/Hobart',
+  'Australia/Lindeman',
+  'Australia/Lord_Howe',
+  'Australia/Melbourne',
+  'Australia/Perth',
+  'Australia/Sydney',
+  'CET',
+  'CST6CDT',
+  'EET',
+  'EST',
+  'EST5EDT',
+  'Etc/GMT',
+  'Etc/GMT+1',
+  'Etc/GMT+10',
+  'Etc/GMT+11',
+  'Etc/GMT+12',
+  'Etc/GMT+2',
+  'Etc/GMT+3',
+  'Etc/GMT+4',
+  'Etc/GMT+5',
+  'Etc/GMT+6',
+  'Etc/GMT+7',
+  'Etc/GMT+8',
+  'Etc/GMT+9',
+  'Etc/GMT-1',
+  'Etc/GMT-10',
+  'Etc/GMT-11',
+  'Etc/GMT-12',
+  'Etc/GMT-13',
+  'Etc/GMT-14',
+  'Etc/GMT-2',
+  'Etc/GMT-3',
+  'Etc/GMT-4',
+  'Etc/GMT-5',
+  'Etc/GMT-6',
+  'Etc/GMT-7',
+  'Etc/GMT-8',
+  'Etc/GMT-9',
+  'Etc/UTC',
+  'Europe/Andorra',
+  'Europe/Astrakhan',
+  'Europe/Athens',
+  'Europe/Belgrade',
+  'Europe/Berlin',
+  'Europe/Brussels',
+  'Europe/Bucharest',
+  'Europe/Budapest',
+  'Europe/Chisinau',
+  'Europe/Dublin',
+  'Europe/Gibraltar',
+  'Europe/Helsinki',
+  'Europe/Istanbul',
+  'Europe/Kaliningrad',
+  'Europe/Kirov',
+  'Europe/Kyiv',
+  'Europe/Lisbon',
+  'Europe/London',
+  'Europe/Madrid',
+  'Europe/Malta',
+  'Europe/Minsk',
+  'Europe/Moscow',
+  'Europe/Paris',
+  'Europe/Prague',
+  'Europe/Riga',
+  'Europe/Rome',
+  'Europe/Samara',
+  'Europe/Saratov',
+  'Europe/Simferopol',
+  'Europe/Sofia',
+  'Europe/Tallinn',
+  'Europe/Tirane',
+  'Europe/Ulyanovsk',
+  'Europe/Vienna',
+  'Europe/Vilnius',
+  'Europe/Volgograd',
+  'Europe/Warsaw',
+  'Europe/Zurich',
+  'HST',
+  'Indian/Chagos',
+  'Indian/Maldives',
+  'Indian/Mauritius',
+  'MET',
+  'MST',
+  'MST7MDT',
+  'PST8PDT',
+  'Pacific/Apia',
+  'Pacific/Auckland',
+  'Pacific/Bougainville',
+  'Pacific/Chatham',
+  'Pacific/Easter',
+  'Pacific/Efate',
+  'Pacific/Fakaofo',
+  'Pacific/Fiji',
+  'Pacific/Galapagos',
+  'Pacific/Gambier',
+  'Pacific/Guadalcanal',
+  'Pacific/Guam',
+  'Pacific/Honolulu',
+  'Pacific/Kanton',
+  'Pacific/Kiritimati',
+  'Pacific/Kosrae',
+  'Pacific/Kwajalein',
+  'Pacific/Marquesas',
+  'Pacific/Nauru',
+  'Pacific/Niue',
+  'Pacific/Norfolk',
+  'Pacific/Noumea',
+  'Pacific/Pago_Pago',
+  'Pacific/Palau',
+  'Pacific/Pitcairn',
+  'Pacific/Port_Moresby',
+  'Pacific/Rarotonga',
+  'Pacific/Tahiti',
+  'Pacific/Tarawa',
+  'Pacific/Tongatapu',
+
+  // IANA TZDB Link names
+  'WET',
+  'Africa/Accra',
+  'Africa/Addis_Ababa',
+  'Africa/Asmara',
+  'Africa/Asmera',
+  'Africa/Bamako',
+  'Africa/Bangui',
+  'Africa/Banjul',
+  'Africa/Blantyre',
+  'Africa/Brazzaville',
+  'Africa/Bujumbura',
+  'Africa/Conakry',
+  'Africa/Dakar',
+  'Africa/Dar_es_Salaam',
+  'Africa/Djibouti',
+  'Africa/Douala',
+  'Africa/Freetown',
+  'Africa/Gaborone',
+  'Africa/Harare',
+  'Africa/Kampala',
+  'Africa/Kigali',
+  'Africa/Kinshasa',
+  'Africa/Libreville',
+  'Africa/Lome',
+  'Africa/Luanda',
+  'Africa/Lubumbashi',
+  'Africa/Lusaka',
+  'Africa/Malabo',
+  'Africa/Maseru',
+  'Africa/Mbabane',
+  'Africa/Mogadishu',
+  'Africa/Niamey',
+  'Africa/Nouakchott',
+  'Africa/Ouagadougou',
+  'Africa/Porto-Novo',
+  'Africa/Timbuktu',
+  'America/Anguilla',
+  'America/Antigua',
+  'America/Argentina/ComodRivadavia',
+  'America/Aruba',
+  'America/Atikokan',
+  'America/Atka',
+  'America/Blanc-Sablon',
+  'America/Buenos_Aires',
+  'America/Catamarca',
+  'America/Cayman',
+  'America/Coral_Harbour',
+  'America/Cordoba',
+  'America/Creston',
+  'America/Curacao',
+  'America/Dominica',
+  'America/Ensenada',
+  'America/Fort_Wayne',
+  'America/Godthab',
+  'America/Grenada',
+  'America/Guadeloupe',
+  'America/Indianapolis',
+  'America/Jujuy',
+  'America/Knox_IN',
+  'America/Kralendijk',
+  'America/Louisville',
+  'America/Lower_Princes',
+  'America/Marigot',
+  'America/Mendoza',
+  'America/Montreal',
+  'America/Montserrat',
+  'America/Nassau',
+  'America/Nipigon',
+  'America/Pangnirtung',
+  'America/Port_of_Spain',
+  'America/Porto_Acre',
+  'America/Rainy_River',
+  'America/Rosario',
+  'America/Santa_Isabel',
+  'America/Shiprock',
+  'America/St_Barthelemy',
+  'America/St_Kitts',
+  'America/St_Lucia',
+  'America/St_Thomas',
+  'America/St_Vincent',
+  'America/Thunder_Bay',
+  'America/Tortola',
+  'America/Virgin',
+  'Antarctica/DumontDUrville',
+  'Antarctica/McMurdo',
+  'Antarctica/South_Pole',
+  'Antarctica/Syowa',
+  'Antarctica/Vostok',
+  'Arctic/Longyearbyen',
+  'Asia/Aden',
+  'Asia/Ashkhabad',
+  'Asia/Bahrain',
+  'Asia/Brunei',
+  'Asia/Calcutta',
+  'Asia/Chongqing',
+  'Asia/Chungking',
+  'Asia/Dacca',
+  'Asia/Harbin',
+  'Asia/Istanbul',
+  'Asia/Kashgar',
+  'Asia/Katmandu',
+  'Asia/Kuala_Lumpur',
+  'Asia/Kuwait',
+  'Asia/Macao',
+  'Asia/Muscat',
+  'Asia/Phnom_Penh',
+  'Asia/Rangoon',
+  'Asia/Saigon',
+  'Asia/Tel_Aviv',
+  'Asia/Thimbu',
+  'Asia/Ujung_Pandang',
+  'Asia/Ulan_Bator',
+  'Asia/Vientiane',
+  'Atlantic/Faeroe',
+  'Atlantic/Jan_Mayen',
+  'Atlantic/Reykjavik',
+  'Atlantic/St_Helena',
+  'Australia/ACT',
+  'Australia/Canberra',
+  'Australia/Currie',
+  'Australia/LHI',
+  'Australia/NSW',
+  'Australia/North',
+  'Australia/Queensland',
+  'Australia/South',
+  'Australia/Tasmania',
+  'Australia/Victoria',
+  'Australia/West',
+  'Australia/Yancowinna',
+  'Brazil/Acre',
+  'Brazil/DeNoronha',
+  'Brazil/East',
+  'Brazil/West',
+  'Canada/Atlantic',
+  'Canada/Central',
+  'Canada/Eastern',
+  'Canada/Mountain',
+  'Canada/Newfoundland',
+  'Canada/Pacific',
+  'Canada/Saskatchewan',
+  'Canada/Yukon',
+  'Chile/Continental',
+  'Chile/EasterIsland',
+  'Cuba',
+  'Egypt',
+  'Eire',
+  'Etc/GMT+0',
+  'Etc/GMT-0',
+  'Etc/GMT0',
+  'Etc/Greenwich',
+  'Etc/UCT',
+  'Etc/Universal',
+  'Etc/Zulu',
+  'Europe/Amsterdam',
+  'Europe/Belfast',
+  'Europe/Bratislava',
+  'Europe/Busingen',
+  'Europe/Copenhagen',
+  'Europe/Guernsey',
+  'Europe/Isle_of_Man',
+  'Europe/Jersey',
+  'Europe/Kiev',
+  'Europe/Ljubljana',
+  'Europe/Luxembourg',
+  'Europe/Mariehamn',
+  'Europe/Monaco',
+  'Europe/Nicosia',
+  'Europe/Oslo',
+  'Europe/Podgorica',
+  'Europe/San_Marino',
+  'Europe/Sarajevo',
+  'Europe/Skopje',
+  'Europe/Stockholm',
+  'Europe/Tiraspol',
+  'Europe/Uzhgorod',
+  'Europe/Vaduz',
+  'Europe/Vatican',
+  'Europe/Zagreb',
+  'Europe/Zaporozhye',
+  'GB',
+  'GB-Eire',
+  'GMT',
+  'GMT+0',
+  'GMT-0',
+  'GMT0',
+  'Greenwich',
+  'Hongkong',
+  'Iceland',
+  'Indian/Antananarivo',
+  'Indian/Christmas',
+  'Indian/Cocos',
+  'Indian/Comoro',
+  'Indian/Kerguelen',
+  'Indian/Mahe',
+  'Indian/Mayotte',
+  'Indian/Reunion',
+  'Iran',
+  'Israel',
+  'Jamaica',
+  'Japan',
+  'Kwajalein',
+  'Libya',
+  'Mexico/BajaNorte',
+  'Mexico/BajaSur',
+  'Mexico/General',
+  'NZ',
+  'NZ-CHAT',
+  'Navajo',
+  'PRC',
+  'Pacific/Chuuk',
+  'Pacific/Enderbury',
+  'Pacific/Funafuti',
+  'Pacific/Johnston',
+  'Pacific/Majuro',
+  'Pacific/Midway',
+  'Pacific/Pohnpei',
+  'Pacific/Ponape',
+  'Pacific/Saipan',
+  'Pacific/Samoa',
+  'Pacific/Truk',
+  'Pacific/Wake',
+  'Pacific/Wallis',
+  'Pacific/Yap',
+  'Poland',
+  'Portugal',
+  'ROC',
+  'ROK',
+  'Singapore',
+  'Turkey',
+  'UCT',
+  'US/Alaska',
+  'US/Aleutian',
+  'US/Arizona',
+  'US/Central',
+  'US/East-Indiana',
+  'US/Eastern',
+  'US/Hawaii',
+  'US/Indiana-Starke',
+  'US/Michigan',
+  'US/Mountain',
+  'US/Pacific',
+  'US/Pacific-New',
+  'US/Samoa',
+  'UTC',
+  'Universal',
+  'W-SU',
+  'Zulu'
+];
+
+// We want to test all available named time zone identifiers (both primary and non-primary),
+// but no ECMAScript built-in API exposes that list. So we use a union of two sources:
+// 1. A hard-coded list of Zone and Link identifiers from the 2022g version of IANA TZDB.
+// 2. Canonical IDs exposed by Intl.supportedValuesOf('timeZone'), which ensures that IDs
+//    added to TZDB later than 2022g will be tested. (New IDs are almost always added as primary.)
+const ids = [...new Set([...timeZoneIdentifiers, ...Intl.supportedValuesOf('timeZone')])];
+for (const id of ids) {
+  const lower = id.toLowerCase();
+  const upper = id.toUpperCase();
+  assert.sameValue(new Temporal.TimeZone(id).toString(), id, `Time zone created from string "${id}"`);
+  assert.sameValue(new Temporal.TimeZone(upper).toString(), id,  `Time zone created from string "${upper}"`);
+  assert.sameValue(new Temporal.TimeZone(lower).toString(), id, `Time zone created from string "${lower}"`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/from/timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/TimeZone/from/timezone-string-datetime.js
new file mode 100644
index 0000000000..c0b0a03f5c
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/from/timezone-string-datetime.js
@@ -0,0 +1,23 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.from
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+const result1 = Temporal.TimeZone.from(timeZone);
+assert.sameValue(result1.id, "America/Vancouver", "date-time + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+const result2 = Temporal.TimeZone.from(timeZone);
+assert.sameValue(result2.id, "America/Vancouver", "date-time + Z + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+const result3 = Temporal.TimeZone.from(timeZone);
+assert.sameValue(result3.id, "America/Vancouver", "date-time + offset + IANA annotation is the IANA time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/iana-legacy-names.js b/js/src/tests/test262/intl402/Temporal/TimeZone/iana-legacy-names.js
new file mode 100644
index 0000000000..150633f6ce
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/iana-legacy-names.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: IANA legacy names must be supported
+features: [Temporal]
+---*/
+
+const legacyNames = [
+  "Etc/GMT0",
+  "GMT0",
+  "GMT-0",
+  "GMT+0",
+  "EST5EDT", 
+  "CST6CDT", 
+  "MST7MDT", 
+  "PST8PDT"
+];
+
+legacyNames.forEach((arg) => {
+  const tz = new Temporal.TimeZone(arg);
+  assert.sameValue(tz.toString(), arg, `"${arg}" does not match "${tz.toString()}" time zone identifier`);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/links-africa.js b/js/src/tests/test262/intl402/Temporal/TimeZone/links-africa.js
new file mode 100644
index 0000000000..0e5ed598b1
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/links-africa.js
@@ -0,0 +1,57 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: >
+  TimeZone constructor accepts link names as its input.
+features: [Temporal]
+---*/
+
+const testCases = [
+  "Africa/Accra",  // Link Africa/Abidjan Africa/Accra        # Ghana
+  "Africa/Bamako",  // Link Africa/Abidjan Africa/Bamako       # Mali
+  "Africa/Banjul",  // Link Africa/Abidjan Africa/Banjul       # The Gambia
+  "Africa/Conakry",  // Link Africa/Abidjan Africa/Conakry      # Guinea
+  "Africa/Dakar",  // Link Africa/Abidjan Africa/Dakar        # Senegal
+  "Africa/Freetown",  // Link Africa/Abidjan Africa/Freetown     # Sierra Leone
+  "Africa/Lome",  // Link Africa/Abidjan Africa/Lome         # Togo
+  "Africa/Nouakchott",  // Link Africa/Abidjan Africa/Nouakchott   # Mauritania
+  "Africa/Ouagadougou",  // Link Africa/Abidjan Africa/Ouagadougou  # Burkina Faso
+  "Atlantic/St_Helena",  // Link Africa/Abidjan Atlantic/St_Helena  # St Helena
+  "Africa/Addis_Ababa",  // Link Africa/Nairobi Africa/Addis_Ababa   # Ethiopia
+  "Africa/Asmara",  // Link Africa/Nairobi Africa/Asmara        # Eritrea
+  "Africa/Dar_es_Salaam",  // Link Africa/Nairobi Africa/Dar_es_Salaam # Tanzania
+  "Africa/Djibouti",  // Link Africa/Nairobi Africa/Djibouti
+  "Africa/Kampala",  // Link Africa/Nairobi Africa/Kampala       # Uganda
+  "Africa/Mogadishu",  // Link Africa/Nairobi Africa/Mogadishu     # Somalia
+  "Indian/Antananarivo",  // Link Africa/Nairobi Indian/Antananarivo  # Madagascar
+  "Indian/Comoro",  // Link Africa/Nairobi Indian/Comoro
+  "Indian/Mayotte",  // Link Africa/Nairobi Indian/Mayotte
+  "Africa/Blantyre",  // Link Africa/Maputo Africa/Blantyre      # Malawi
+  "Africa/Bujumbura",  // Link Africa/Maputo Africa/Bujumbura     # Burundi
+  "Africa/Gaborone",  // Link Africa/Maputo Africa/Gaborone      # Botswana
+  "Africa/Harare",  // Link Africa/Maputo Africa/Harare        # Zimbabwe
+  "Africa/Kigali",  // Link Africa/Maputo Africa/Kigali        # Rwanda
+  "Africa/Lubumbashi",  // Link Africa/Maputo Africa/Lubumbashi    # E Dem. Rep. of Congo
+  "Africa/Lusaka",  // Link Africa/Maputo Africa/Lusaka        # Zambia
+  "Africa/Bangui",  // Link Africa/Lagos Africa/Bangui         # Central African Republic
+  "Africa/Brazzaville",  // Link Africa/Lagos Africa/Brazzaville    # Rep. of the Congo
+  "Africa/Douala",  // Link Africa/Lagos Africa/Douala         # Cameroon
+  "Africa/Kinshasa",  // Link Africa/Lagos Africa/Kinshasa       # Dem. Rep. of the Congo (west)
+  "Africa/Libreville",  // Link Africa/Lagos Africa/Libreville     # Gabon
+  "Africa/Luanda",  // Link Africa/Lagos Africa/Luanda         # Angola
+  "Africa/Malabo",  // Link Africa/Lagos Africa/Malabo         # Equatorial Guinea
+  "Africa/Niamey",  // Link Africa/Lagos Africa/Niamey         # Niger
+  "Africa/Porto-Novo",  // Link Africa/Lagos Africa/Porto-Novo     # Benin
+  "Africa/Maseru",  // Link Africa/Johannesburg Africa/Maseru  # Lesotho
+  "Africa/Mbabane",  // Link Africa/Johannesburg Africa/Mbabane # Eswatini
+];
+
+for (let id of testCases) {
+  const tz = new Temporal.TimeZone(id);
+  assert.sameValue(tz.id, id);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/links-asia.js b/js/src/tests/test262/intl402/Temporal/TimeZone/links-asia.js
new file mode 100644
index 0000000000..80b5b3e62d
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/links-asia.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: >
+  TimeZone constructor accepts link names as its input.
+features: [Temporal]
+---*/
+
+const testCases = [
+  "Europe/Nicosia",  // Link    Asia/Nicosia    Europe/Nicosia
+  "Asia/Bahrain",  // Link Asia/Qatar Asia/Bahrain
+  "Antarctica/Syowa",  // Link Asia/Riyadh Antarctica/Syowa
+  "Asia/Aden",  // Link Asia/Riyadh Asia/Aden      # Yemen
+  "Asia/Kuwait",  // Link Asia/Riyadh Asia/Kuwait
+  "Asia/Phnom_Penh",  // Link Asia/Bangkok Asia/Phnom_Penh       # Cambodia
+  "Asia/Vientiane",  // Link Asia/Bangkok Asia/Vientiane        # Laos
+  "Asia/Muscat",  // Link Asia/Dubai Asia/Muscat     # Oman
+];
+
+for (let id of testCases) {
+  const tz = new Temporal.TimeZone(id);
+  assert.sameValue(tz.id, id);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/links-australasia.js b/js/src/tests/test262/intl402/Temporal/TimeZone/links-australasia.js
new file mode 100644
index 0000000000..b24164d8f3
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/links-australasia.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: >
+  TimeZone constructor accepts link names as its input.
+features: [Temporal]
+---*/
+
+const testCases = [
+  "Pacific/Saipan",  // Link Pacific/Guam Pacific/Saipan # N Mariana Is
+  "Antarctica/McMurdo",  // Link Pacific/Auckland Antarctica/McMurdo
+  "Antarctica/DumontDUrville",  // Link Pacific/Port_Moresby Antarctica/DumontDUrville
+  "Pacific/Midway",  // Link Pacific/Pago_Pago Pacific/Midway # in US minor outlying islands
+];
+
+for (let id of testCases) {
+  const tz = new Temporal.TimeZone(id);
+  assert.sameValue(tz.id, id);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/links-backward.js b/js/src/tests/test262/intl402/Temporal/TimeZone/links-backward.js
new file mode 100644
index 0000000000..afab22aa45
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/links-backward.js
@@ -0,0 +1,143 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: >
+  TimeZone constructor accepts link names as its input.
+features: [Temporal]
+---*/
+
+const testCases = [
+  "Africa/Asmera",  // Link    Africa/Nairobi          Africa/Asmera
+  "Africa/Timbuktu",  // Link    Africa/Abidjan          Africa/Timbuktu
+  "America/Argentina/ComodRivadavia",  // Link    America/Argentina/Catamarca     America/Argentina/ComodRivadavia
+  "America/Atka",  // Link    America/Adak            America/Atka
+  "America/Buenos_Aires",  // Link    America/Argentina/Buenos_Aires  America/Buenos_Aires
+  "America/Catamarca",  // Link    America/Argentina/Catamarca     America/Catamarca
+  "America/Coral_Harbour",  // Link    America/Panama          America/Coral_Harbour
+  "America/Cordoba",  // Link    America/Argentina/Cordoba       America/Cordoba
+  "America/Ensenada",  // Link    America/Tijuana         America/Ensenada
+  "America/Fort_Wayne",  // Link    America/Indiana/Indianapolis    America/Fort_Wayne
+  "America/Godthab",  // Link    America/Nuuk            America/Godthab
+  "America/Indianapolis",  // Link    America/Indiana/Indianapolis    America/Indianapolis
+  "America/Jujuy",  // Link    America/Argentina/Jujuy America/Jujuy
+  "America/Knox_IN",  // Link    America/Indiana/Knox    America/Knox_IN
+  "America/Louisville",  // Link    America/Kentucky/Louisville     America/Louisville
+  "America/Mendoza",  // Link    America/Argentina/Mendoza       America/Mendoza
+  "America/Montreal",  // Link    America/Toronto         America/Montreal
+  "America/Porto_Acre",  // Link    America/Rio_Branco      America/Porto_Acre
+  "America/Rosario",  // Link    America/Argentina/Cordoba       America/Rosario
+  "America/Santa_Isabel",  // Link    America/Tijuana         America/Santa_Isabel
+  "America/Shiprock",  // Link    America/Denver          America/Shiprock
+  "America/Virgin",  // Link    America/Puerto_Rico     America/Virgin
+  "Antarctica/South_Pole",  // Link    Pacific/Auckland        Antarctica/South_Pole
+  "Asia/Ashkhabad",  // Link    Asia/Ashgabat           Asia/Ashkhabad
+  "Asia/Calcutta",  // Link    Asia/Kolkata            Asia/Calcutta
+  "Asia/Chongqing",  // Link    Asia/Shanghai           Asia/Chongqing
+  "Asia/Chungking",  // Link    Asia/Shanghai           Asia/Chungking
+  "Asia/Dacca",  // Link    Asia/Dhaka              Asia/Dacca
+  "Asia/Harbin",  // Link    Asia/Shanghai           Asia/Harbin
+  "Asia/Kashgar",  // Link    Asia/Urumqi             Asia/Kashgar
+  "Asia/Katmandu",  // Link    Asia/Kathmandu          Asia/Katmandu
+  "Asia/Macao",  // Link    Asia/Macau              Asia/Macao
+  "Asia/Rangoon",  // Link    Asia/Yangon             Asia/Rangoon
+  "Asia/Saigon",  // Link    Asia/Ho_Chi_Minh        Asia/Saigon
+  "Asia/Tel_Aviv",  // Link    Asia/Jerusalem          Asia/Tel_Aviv
+  "Asia/Thimbu",  // Link    Asia/Thimphu            Asia/Thimbu
+  "Asia/Ujung_Pandang",  // Link    Asia/Makassar           Asia/Ujung_Pandang
+  "Asia/Ulan_Bator",  // Link    Asia/Ulaanbaatar        Asia/Ulan_Bator
+  "Atlantic/Faeroe",  // Link    Atlantic/Faroe          Atlantic/Faeroe
+  "Atlantic/Jan_Mayen",  // Link    Europe/Oslo             Atlantic/Jan_Mayen
+  "Australia/ACT",  // Link    Australia/Sydney        Australia/ACT
+  "Australia/Canberra",  // Link    Australia/Sydney        Australia/Canberra
+  "Australia/Currie",  // Link    Australia/Hobart        Australia/Currie
+  "Australia/LHI",  // Link    Australia/Lord_Howe     Australia/LHI
+  "Australia/NSW",  // Link    Australia/Sydney        Australia/NSW
+  "Australia/North",  // Link    Australia/Darwin        Australia/North
+  "Australia/Queensland",  // Link    Australia/Brisbane      Australia/Queensland
+  "Australia/South",  // Link    Australia/Adelaide      Australia/South
+  "Australia/Tasmania",  // Link    Australia/Hobart        Australia/Tasmania
+  "Australia/Victoria",  // Link    Australia/Melbourne     Australia/Victoria
+  "Australia/West",  // Link    Australia/Perth         Australia/West
+  "Australia/Yancowinna",  // Link    Australia/Broken_Hill   Australia/Yancowinna
+  "Brazil/Acre",  // Link    America/Rio_Branco      Brazil/Acre
+  "Brazil/DeNoronha",  // Link    America/Noronha         Brazil/DeNoronha
+  "Brazil/East",  // Link    America/Sao_Paulo       Brazil/East
+  "Brazil/West",  // Link    America/Manaus          Brazil/West
+  "Canada/Atlantic",  // Link    America/Halifax         Canada/Atlantic
+  "Canada/Central",  // Link    America/Winnipeg        Canada/Central
+  "Canada/Eastern",  // Link    America/Toronto         Canada/Eastern
+  "Canada/Mountain",  // Link    America/Edmonton        Canada/Mountain
+  "Canada/Newfoundland",  // Link    America/St_Johns        Canada/Newfoundland
+  "Canada/Pacific",  // Link    America/Vancouver       Canada/Pacific
+  "Canada/Saskatchewan",  // Link    America/Regina          Canada/Saskatchewan
+  "Canada/Yukon",  // Link    America/Whitehorse      Canada/Yukon
+  "Chile/Continental",  // Link    America/Santiago        Chile/Continental
+  "Chile/EasterIsland",  // Link    Pacific/Easter          Chile/EasterIsland
+  "Cuba",  // Link    America/Havana          Cuba
+  "Egypt",  // Link    Africa/Cairo            Egypt
+  "Eire",  // Link    Europe/Dublin           Eire
+  "Etc/UCT",  // Link    Etc/UTC                 Etc/UCT
+  "Europe/Belfast",  // Link    Europe/London           Europe/Belfast
+  "Europe/Kiev",  // Link    Europe/Kyiv             Europe/Kiev
+  "Europe/Tiraspol",  // Link    Europe/Chisinau         Europe/Tiraspol
+  "GB",  // Link    Europe/London           GB
+  "GB-Eire",  // Link    Europe/London           GB-Eire
+  "GMT+0",  // Link    Etc/GMT                 GMT+0
+  "GMT-0",  // Link    Etc/GMT                 GMT-0
+  "GMT0",  // Link    Etc/GMT                 GMT0
+  "Greenwich",  // Link    Etc/GMT                 Greenwich
+  "Hongkong",  // Link    Asia/Hong_Kong          Hongkong
+  "Iceland",  // Link    Atlantic/Reykjavik      Iceland
+  "Iran",  // Link    Asia/Tehran             Iran
+  "Israel",  // Link    Asia/Jerusalem          Israel
+  "Jamaica",  // Link    America/Jamaica         Jamaica
+  "Japan",  // Link    Asia/Tokyo              Japan
+  "Kwajalein",  // Link    Pacific/Kwajalein       Kwajalein
+  "Libya",  // Link    Africa/Tripoli          Libya
+  "Mexico/BajaNorte",  // Link    America/Tijuana         Mexico/BajaNorte
+  "Mexico/BajaSur",  // Link    America/Mazatlan        Mexico/BajaSur
+  "Mexico/General",  // Link    America/Mexico_City     Mexico/General
+  "NZ",  // Link    Pacific/Auckland        NZ
+  "NZ-CHAT",  // Link    Pacific/Chatham         NZ-CHAT
+  "Navajo",  // Link    America/Denver          Navajo
+  "PRC",  // Link    Asia/Shanghai           PRC
+  "Pacific/Enderbury",  // Link    Pacific/Kanton          Pacific/Enderbury
+  "Pacific/Johnston",  // Link    Pacific/Honolulu        Pacific/Johnston
+  "Pacific/Ponape",  // Link    Pacific/Pohnpei         Pacific/Ponape
+  "Pacific/Samoa",  // Link    Pacific/Pago_Pago       Pacific/Samoa
+  "Pacific/Truk",  // Link    Pacific/Chuuk           Pacific/Truk
+  "Pacific/Yap",  // Link    Pacific/Chuuk           Pacific/Yap
+  "Poland",  // Link    Europe/Warsaw           Poland
+  "Portugal",  // Link    Europe/Lisbon           Portugal
+  "ROC",  // Link    Asia/Taipei             ROC
+  "ROK",  // Link    Asia/Seoul              ROK
+  "Singapore",  // Link    Asia/Singapore          Singapore
+  "Turkey",  // Link    Europe/Istanbul         Turkey
+  "UCT",  // Link    Etc/UTC                 UCT
+  "US/Alaska",  // Link    America/Anchorage       US/Alaska
+  "US/Aleutian",  // Link    America/Adak            US/Aleutian
+  "US/Arizona",  // Link    America/Phoenix         US/Arizona
+  "US/Central",  // Link    America/Chicago         US/Central
+  "US/East-Indiana",  // Link    America/Indiana/Indianapolis    US/East-Indiana
+  "US/Eastern",  // Link    America/New_York        US/Eastern
+  "US/Hawaii",  // Link    Pacific/Honolulu        US/Hawaii
+  "US/Indiana-Starke",  // Link    America/Indiana/Knox    US/Indiana-Starke
+  "US/Michigan",  // Link    America/Detroit         US/Michigan
+  "US/Mountain",  // Link    America/Denver          US/Mountain
+  "US/Pacific",  // Link    America/Los_Angeles     US/Pacific
+  "US/Samoa",  // Link    Pacific/Pago_Pago       US/Samoa
+  "UTC",  // Link    Etc/UTC                 UTC
+  "Universal",  // Link    Etc/UTC                 Universal
+  "W-SU",  // Link    Europe/Moscow           W-SU
+  "Zulu",  // Link    Etc/UTC                 Zulu
+];
+
+for (let id of testCases) {
+  const tz = new Temporal.TimeZone(id);
+  assert.sameValue(tz.id, id);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/links-backzone.js b/js/src/tests/test262/intl402/Temporal/TimeZone/links-backzone.js
new file mode 100644
index 0000000000..90eb8dca19
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/links-backzone.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: >
+  TimeZone constructor accepts link names as its input.
+features: [Temporal]
+---*/
+
+const testCases = [
+  "Africa/Asmera",  // Link Africa/Asmara Africa/Asmera
+  "America/Kralendijk",  // Link    America/Curacao America/Kralendijk
+  "America/Lower_Princes",  // Link    America/Curacao America/Lower_Princes
+  "America/Marigot",  // Link America/Port_of_Spain America/Marigot
+  "America/St_Barthelemy",  // Link America/Port_of_Spain America/St_Barthelemy
+  "America/Virgin",  // Link America/St_Thomas America/Virgin
+  "Antarctica/South_Pole",  // Link Antarctica/McMurdo Antarctica/South_Pole
+  "Asia/Chungking",  // Link Asia/Chongqing Asia/Chungking
+];
+
+for (let id of testCases) {
+  const tz = new Temporal.TimeZone(id);
+  assert.sameValue(tz.id, id);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/links-etcetera.js b/js/src/tests/test262/intl402/Temporal/TimeZone/links-etcetera.js
new file mode 100644
index 0000000000..e67c2bea7a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/links-etcetera.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: >
+  TimeZone constructor accepts link names as its input.
+features: [Temporal]
+---*/
+
+const testCases = [
+  "GMT",  // Link    Etc/GMT                         GMT
+  "Etc/Universal",  // Link    Etc/UTC                         Etc/Universal
+  "Etc/Zulu",  // Link    Etc/UTC                         Etc/Zulu
+  "Etc/Greenwich",  // Link    Etc/GMT                         Etc/Greenwich
+  "Etc/GMT-0",  // Link    Etc/GMT                         Etc/GMT-0
+  "Etc/GMT+0",  // Link    Etc/GMT                         Etc/GMT+0
+  "Etc/GMT0",  // Link    Etc/GMT                         Etc/GMT0
+];
+
+for (let id of testCases) {
+  const tz = new Temporal.TimeZone(id);
+  assert.sameValue(tz.id, id);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/links-europe.js b/js/src/tests/test262/intl402/Temporal/TimeZone/links-europe.js
new file mode 100644
index 0000000000..81149e8d12
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/links-europe.js
@@ -0,0 +1,36 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: >
+  TimeZone constructor accepts link names as its input.
+features: [Temporal]
+---*/
+
+const testCases = [
+  "Europe/Jersey",  // Link    Europe/London   Europe/Jersey
+  "Europe/Guernsey",  // Link    Europe/London   Europe/Guernsey
+  "Europe/Isle_of_Man",  // Link    Europe/London   Europe/Isle_of_Man
+  "Europe/Mariehamn",  // Link    Europe/Helsinki Europe/Mariehamn
+  "Europe/Busingen",  // Link    Europe/Zurich   Europe/Busingen
+  "Europe/Vatican",  // Link    Europe/Rome     Europe/Vatican
+  "Europe/San_Marino",  // Link    Europe/Rome     Europe/San_Marino
+  "Europe/Vaduz",  // Link Europe/Zurich Europe/Vaduz
+  "Arctic/Longyearbyen",  // Link    Europe/Oslo     Arctic/Longyearbyen
+  "Europe/Ljubljana",  // Link Europe/Belgrade Europe/Ljubljana   # Slovenia
+  "Europe/Podgorica",  // Link Europe/Belgrade Europe/Podgorica   # Montenegro
+  "Europe/Sarajevo",  // Link Europe/Belgrade Europe/Sarajevo    # Bosnia and Herzegovina
+  "Europe/Skopje",  // Link Europe/Belgrade Europe/Skopje      # North Macedonia
+  "Europe/Zagreb",  // Link Europe/Belgrade Europe/Zagreb      # Croatia
+  "Europe/Bratislava",  // Link Europe/Prague Europe/Bratislava
+  "Asia/Istanbul",  // Link    Europe/Istanbul Asia/Istanbul   # Istanbul is in both continents.
+];
+
+for (let id of testCases) {
+  const tz = new Temporal.TimeZone(id);
+  assert.sameValue(tz.id, id);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/links-northamerica.js b/js/src/tests/test262/intl402/Temporal/TimeZone/links-northamerica.js
new file mode 100644
index 0000000000..c1b24fe974
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/links-northamerica.js
@@ -0,0 +1,43 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: >
+  TimeZone constructor accepts link names as its input.
+features: [Temporal]
+---*/
+
+const testCases = [
+  "America/Creston",  // Link America/Phoenix America/Creston
+  "America/Nassau",  // Link America/Toronto America/Nassau
+  "America/Atikokan",  // Link America/Panama America/Atikokan
+  "America/Cayman",  // Link America/Panama America/Cayman
+  "America/Anguilla",  // Link America/Puerto_Rico America/Anguilla
+  "America/Antigua",  // Link America/Puerto_Rico America/Antigua
+  "America/Aruba",  // Link America/Puerto_Rico America/Aruba
+  "America/Curacao",  // Link America/Puerto_Rico America/Curacao
+  "America/Blanc-Sablon",  // Link America/Puerto_Rico America/Blanc-Sablon   # Quebec (Lower North Shore)
+  "America/Dominica",  // Link America/Puerto_Rico America/Dominica
+  "America/Grenada",  // Link America/Puerto_Rico America/Grenada
+  "America/Guadeloupe",  // Link America/Puerto_Rico America/Guadeloupe
+  "America/Kralendijk",  // Link America/Puerto_Rico America/Kralendijk     # Caribbean Netherlands
+  "America/Lower_Princes",  // Link America/Puerto_Rico America/Lower_Princes  # Sint Maarten
+  "America/Marigot",  // Link America/Puerto_Rico America/Marigot        # St Martin (French part)
+  "America/Montserrat",  // Link America/Puerto_Rico America/Montserrat
+  "America/Port_of_Spain",  // Link America/Puerto_Rico America/Port_of_Spain  # Trinidad & Tobago
+  "America/St_Barthelemy",  // Link America/Puerto_Rico America/St_Barthelemy  # St Barthélemy
+  "America/St_Kitts",  // Link America/Puerto_Rico America/St_Kitts       # St Kitts & Nevis
+  "America/St_Lucia",  // Link America/Puerto_Rico America/St_Lucia
+  "America/St_Thomas",  // Link America/Puerto_Rico America/St_Thomas      # Virgin Islands (US)
+  "America/St_Vincent",  // Link America/Puerto_Rico America/St_Vincent
+  "America/Tortola",  // Link America/Puerto_Rico America/Tortola        # Virgin Islands (UK)
+];
+
+for (let id of testCases) {
+  const tz = new Temporal.TimeZone(id);
+  assert.sameValue(tz.id, id);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/non-canonical-utc.js b/js/src/tests/test262/intl402/Temporal/TimeZone/non-canonical-utc.js
new file mode 100644
index 0000000000..468ecd2afd
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/non-canonical-utc.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: >
+  TimeZone constructor canonicalises its input.
+features: [Temporal]
+---*/
+
+const testCases = [
+  "Etc/GMT",
+  "Etc/GMT+0",
+  "Etc/GMT-0",
+  "Etc/GMT0",
+  "Etc/Greenwich",
+  "Etc/UCT",
+  "Etc/UTC",
+  "Etc/Universal",
+  "Etc/Zulu",
+];
+
+for (let id of testCases) {
+  let tz = new Temporal.TimeZone(id);
+
+  assert.sameValue(tz.id, id);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/browser.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/argument-object.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/argument-object.js
new file mode 100644
index 0000000000..551550d21a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/argument-object.js
@@ -0,0 +1,84 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.from
+description: Objects with IANA IDs are compared case-insensitively with their canonical IDs
+features: [Temporal]
+---*/
+
+class CustomTimeZone extends Temporal.TimeZone {
+  constructor(id) {
+    super("UTC");
+    this._id = id;
+  }
+  get id() {
+    return this._id;
+  }
+}
+
+const classInstancesIANA = [
+  new Temporal.TimeZone("Asia/Calcutta"),
+  new CustomTimeZone("Asia/Calcutta"),
+  new Temporal.TimeZone("Asia/Kolkata"),
+  new CustomTimeZone("Asia/Kolkata"),
+  new CustomTimeZone("ASIA/calcutta"),
+  new CustomTimeZone("Asia/KOLKATA")
+];
+
+const plainObjectsIANA = [
+  { id: "Asia/Calcutta", getPossibleInstantsFor: null, getOffsetNanosecondsFor: null },
+  { id: "Asia/Kolkata", getPossibleInstantsFor: null, getOffsetNanosecondsFor: null },
+  { id: "ASIA/calcutta", getPossibleInstantsFor: null, getOffsetNanosecondsFor: null },
+  { id: "asia/kolkatA", getPossibleInstantsFor: null, getOffsetNanosecondsFor: null }
+];
+
+for (const object1 of classInstancesIANA) {
+  for (const object2 of classInstancesIANA) {
+    assert.sameValue(object1.equals(object2), true, `Receiver ${object1.id} should not equal argument ${object2.id}`);
+  }
+  for (const object2 of plainObjectsIANA) {
+    assert.sameValue(object1.equals(object2), true, `Receiver ${object2.id} should not equal argument ${object1.id}`);
+  }
+}
+
+const classInstancesIANADifferentCanonical = [
+  new Temporal.TimeZone("Asia/Colombo"),
+  new CustomTimeZone("Asia/Colombo"),
+  new Temporal.TimeZone("ASIA/colombo"),
+  new CustomTimeZone("ASIA/colombo")
+];
+
+for (const object1 of classInstancesIANADifferentCanonical) {
+  for (const object2 of classInstancesIANA) {
+    assert.sameValue(object1.equals(object2), false, `Receiver ${object1.id} should not equal argument ${object2.id}`);
+    assert.sameValue(object2.equals(object1), false, `Receiver ${object2.id} should not equal argument ${object1.id}`);
+  }
+  for (const object2 of plainObjectsIANA) {
+    assert.sameValue(object1.equals(object2), false, `Receiver ${object1.id} should not equal argument ${object2.id}`);
+    assert.sameValue(
+      object1.equals(object2.id),
+      false,
+      `Receiver ${object1.id} should not equal argument ${object2.id}`
+    );
+  }
+}
+
+const classInstancesCustomNotIANA = [new CustomTimeZone("Moon/Cheese")];
+for (const object1 of classInstancesCustomNotIANA) {
+  for (const object2 of classInstancesIANA) {
+    assert.sameValue(object1.equals(object2), false, `Receiver ${object1.id} should not equal argument ${object2.id}`);
+    assert.sameValue(object2.equals(object1), false, `Receiver ${object2.id} should not equal argument ${object1.id}`);
+  }
+  for (const object2 of plainObjectsIANA) {
+    assert.sameValue(object1.equals(object2), false, `Receiver ${object1.id} should not equal argument ${object2.id}`);
+    assert.sameValue(
+      object1.equals(object2.id),
+      false,
+      `Receiver ${object1.id} should not equal argument ${object2.id}`
+    );
+  }
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/argument-valid.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/argument-valid.js
new file mode 100644
index 0000000000..836a3eff24
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/argument-valid.js
@@ -0,0 +1,29 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.from
+description: Built-in time zones are parsed correctly out of valid strings
+features: [Temporal]
+---*/
+
+const valids = [
+  ["Africa/CAIRO", "Africa/Cairo"],
+  ["Asia/Ulan_Bator", "Asia/Ulaanbaatar"],
+  ["etc/gmt", "Etc/GMT"],
+  ["1994-11-05T08:15:30-05:00[America/New_York]", "America/New_York"],
+  ["1994-11-05T08:15:30+05:30[Asia/Calcutta]", "Asia/Calcutta"],
+  ["1994-11-05T08:15:30+05:30[Asia/Calcutta]", "Asia/Kolkata"],
+  ["1994-11-05T08:15:30+05:30[Asia/Kolkata]", "Asia/Calcutta"],
+  ["1994-11-05T08:15:30+05:30[Asia/Kolkata]", "Asia/Kolkata"],
+];
+
+for (const [valid, canonical = valid] of valids) {
+  const tzValid = Temporal.TimeZone.from(canonical);
+  const tzCanonical = Temporal.TimeZone.from(canonical);
+  assert.sameValue(tzValid.equals(tzCanonical), true);
+  assert.sameValue(tzCanonical.equals(tzValid), true);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/browser.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/canonical-iana-names.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/canonical-iana-names.js
new file mode 100644
index 0000000000..6be500a228
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/canonical-iana-names.js
@@ -0,0 +1,50 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.from
+description: Canonicalizes to evaluate time zone equality
+features: [Temporal]
+---*/
+
+const neverEqual = new Temporal.TimeZone('Asia/Tokyo');
+const zdt = new Temporal.ZonedDateTime(0n, 'America/Los_Angeles');
+const ids = [
+  ['America/Atka', 'America/Adak'],
+  ['America/Knox_IN', 'America/Indiana/Knox'],
+  ['Asia/Ashkhabad', 'Asia/Ashgabat'],
+  ['Asia/Dacca', 'Asia/Dhaka'],
+  ['Asia/Istanbul', 'Europe/Istanbul'],
+  ['Asia/Macao', 'Asia/Macau'],
+  ['Asia/Thimbu', 'Asia/Thimphu'],
+  ['Asia/Ujung_Pandang', 'Asia/Makassar'],
+  ['Asia/Ulan_Bator', 'Asia/Ulaanbaatar']
+];
+
+for (const [identifier, primaryIdentifier] of ids) {
+  const tz1 = new Temporal.TimeZone(identifier);
+  const tz2 = new Temporal.TimeZone(primaryIdentifier);
+
+  // compare objects
+  assert.sameValue(tz1.equals(tz2), true);
+  assert.sameValue(tz2.equals(tz1), true);
+  assert.sameValue(tz1.equals(neverEqual), false);
+
+  // compare string IDs
+  assert.sameValue(tz1.equals(tz2.id), true);
+  assert.sameValue(tz2.equals(tz1.id), true);
+  assert.sameValue(tz1.equals(neverEqual.id), false);
+
+  // compare ZonedDateTime instances
+  assert.sameValue(tz1.equals(zdt.withTimeZone(tz2)), true);
+  assert.sameValue(tz2.equals(zdt.withTimeZone(tz1)), true);
+  assert.sameValue(tz1.equals(zdt.withTimeZone(neverEqual)), false);
+
+  // compare IXDTF strings
+  assert.sameValue(tz1.equals(zdt.withTimeZone(tz2).toString()), true);
+  assert.sameValue(tz2.equals(zdt.withTimeZone(tz1).toString()), true);
+  assert.sameValue(tz1.equals(zdt.withTimeZone(neverEqual).toString()), false);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/canonical-not-equal.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/canonical-not-equal.js
new file mode 100644
index 0000000000..f37c49054d
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/canonical-not-equal.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.from
+description: Canonical time zone identifiers are never equal to each other
+features: [Temporal]
+---*/
+
+// supportedValuesOf only returns canonical IDs
+const ids = Intl.supportedValuesOf("timeZone");
+
+const forEachDistinctPair = (array, func) => {
+  for (let i = 0; i < array.length; i++) {
+    for (let j = i + 1; j < array.length; j++) {
+      func(array[i], array[j]);
+    }
+  }
+};
+
+forEachDistinctPair(ids, (id1, id2) => {
+  const tz = new Temporal.TimeZone(id1);
+  assert.sameValue(tz.equals(id2), false);
+})
+
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/offset-and-iana.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/offset-and-iana.js
new file mode 100644
index 0000000000..af9579cf53
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/offset-and-iana.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: Offset string time zones compare as expected
+features: [Temporal]
+---*/
+
+const zdt = new Temporal.ZonedDateTime(0n, "America/Los_Angeles");
+const otz1 = new Temporal.TimeZone("+05:30");
+const otz2 = new Temporal.TimeZone("+0530");
+const tz = new Temporal.TimeZone("Asia/Kolkata");
+assert.sameValue(otz1.equals(otz2), true);
+assert.sameValue(otz2.equals(otz1), true);
+assert.sameValue(otz1.equals("+05:30"), true);
+assert.sameValue(otz1.equals(zdt.withTimeZone(otz2)), true);
+assert.sameValue(otz1.equals(zdt.withTimeZone(otz2).toString()), true);
+assert.sameValue(otz1.equals(tz), false);
+assert.sameValue(otz1.equals("Asia/Kolkata"), false);
+assert.sameValue(otz1.equals(zdt.withTimeZone(tz)), false);
+assert.sameValue(otz1.equals(zdt.withTimeZone(tz).toString()), false);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/shell.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/timezone-case-insensitive.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/timezone-case-insensitive.js
new file mode 100644
index 0000000000..f586342153
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/equals/timezone-case-insensitive.js
@@ -0,0 +1,627 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.from
+description: Time zone names are compared case-insensitively
+features: [Temporal]
+---*/
+
+const timeZoneIdentifiers = [
+  // IANA TZDB Zone names
+  'Africa/Abidjan',
+  'Africa/Algiers',
+  'Africa/Bissau',
+  'Africa/Cairo',
+  'Africa/Casablanca',
+  'Africa/Ceuta',
+  'Africa/El_Aaiun',
+  'Africa/Johannesburg',
+  'Africa/Juba',
+  'Africa/Khartoum',
+  'Africa/Lagos',
+  'Africa/Maputo',
+  'Africa/Monrovia',
+  'Africa/Nairobi',
+  'Africa/Ndjamena',
+  'Africa/Sao_Tome',
+  'Africa/Tripoli',
+  'Africa/Tunis',
+  'Africa/Windhoek',
+  'America/Adak',
+  'America/Anchorage',
+  'America/Araguaina',
+  'America/Argentina/Buenos_Aires',
+  'America/Argentina/Catamarca',
+  'America/Argentina/Cordoba',
+  'America/Argentina/Jujuy',
+  'America/Argentina/La_Rioja',
+  'America/Argentina/Mendoza',
+  'America/Argentina/Rio_Gallegos',
+  'America/Argentina/Salta',
+  'America/Argentina/San_Juan',
+  'America/Argentina/San_Luis',
+  'America/Argentina/Tucuman',
+  'America/Argentina/Ushuaia',
+  'America/Asuncion',
+  'America/Bahia',
+  'America/Bahia_Banderas',
+  'America/Barbados',
+  'America/Belem',
+  'America/Belize',
+  'America/Boa_Vista',
+  'America/Bogota',
+  'America/Boise',
+  'America/Cambridge_Bay',
+  'America/Campo_Grande',
+  'America/Cancun',
+  'America/Caracas',
+  'America/Cayenne',
+  'America/Chicago',
+  'America/Chihuahua',
+  // 'America/Ciudad_Juarez' // uncomment after Node supports this ID added in TZDB 2022g
+  'America/Costa_Rica',
+  'America/Cuiaba',
+  'America/Danmarkshavn',
+  'America/Dawson',
+  'America/Dawson_Creek',
+  'America/Denver',
+  'America/Detroit',
+  'America/Edmonton',
+  'America/Eirunepe',
+  'America/El_Salvador',
+  'America/Fort_Nelson',
+  'America/Fortaleza',
+  'America/Glace_Bay',
+  'America/Goose_Bay',
+  'America/Grand_Turk',
+  'America/Guatemala',
+  'America/Guayaquil',
+  'America/Guyana',
+  'America/Halifax',
+  'America/Havana',
+  'America/Hermosillo',
+  'America/Indiana/Indianapolis',
+  'America/Indiana/Knox',
+  'America/Indiana/Marengo',
+  'America/Indiana/Petersburg',
+  'America/Indiana/Tell_City',
+  'America/Indiana/Vevay',
+  'America/Indiana/Vincennes',
+  'America/Indiana/Winamac',
+  'America/Inuvik',
+  'America/Iqaluit',
+  'America/Jamaica',
+  'America/Juneau',
+  'America/Kentucky/Louisville',
+  'America/Kentucky/Monticello',
+  'America/La_Paz',
+  'America/Lima',
+  'America/Los_Angeles',
+  'America/Maceio',
+  'America/Managua',
+  'America/Manaus',
+  'America/Martinique',
+  'America/Matamoros',
+  'America/Mazatlan',
+  'America/Menominee',
+  'America/Merida',
+  'America/Metlakatla',
+  'America/Mexico_City',
+  'America/Miquelon',
+  'America/Moncton',
+  'America/Monterrey',
+  'America/Montevideo',
+  'America/New_York',
+  'America/Nome',
+  'America/Noronha',
+  'America/North_Dakota/Beulah',
+  'America/North_Dakota/Center',
+  'America/North_Dakota/New_Salem',
+  'America/Nuuk',
+  'America/Ojinaga',
+  'America/Panama',
+  'America/Paramaribo',
+  'America/Phoenix',
+  'America/Port-au-Prince',
+  'America/Porto_Velho',
+  'America/Puerto_Rico',
+  'America/Punta_Arenas',
+  'America/Rankin_Inlet',
+  'America/Recife',
+  'America/Regina',
+  'America/Resolute',
+  'America/Rio_Branco',
+  'America/Santarem',
+  'America/Santiago',
+  'America/Santo_Domingo',
+  'America/Sao_Paulo',
+  'America/Scoresbysund',
+  'America/Sitka',
+  'America/St_Johns',
+  'America/Swift_Current',
+  'America/Tegucigalpa',
+  'America/Thule',
+  'America/Tijuana',
+  'America/Toronto',
+  'America/Vancouver',
+  'America/Whitehorse',
+  'America/Winnipeg',
+  'America/Yakutat',
+  'America/Yellowknife',
+  'Antarctica/Casey',
+  'Antarctica/Davis',
+  'Antarctica/Macquarie',
+  'Antarctica/Mawson',
+  'Antarctica/Palmer',
+  'Antarctica/Rothera',
+  'Antarctica/Troll',
+  'Asia/Almaty',
+  'Asia/Amman',
+  'Asia/Anadyr',
+  'Asia/Aqtau',
+  'Asia/Aqtobe',
+  'Asia/Ashgabat',
+  'Asia/Atyrau',
+  'Asia/Baghdad',
+  'Asia/Baku',
+  'Asia/Bangkok',
+  'Asia/Barnaul',
+  'Asia/Beirut',
+  'Asia/Bishkek',
+  'Asia/Chita',
+  'Asia/Choibalsan',
+  'Asia/Colombo',
+  'Asia/Damascus',
+  'Asia/Dhaka',
+  'Asia/Dili',
+  'Asia/Dubai',
+  'Asia/Dushanbe',
+  'Asia/Famagusta',
+  'Asia/Gaza',
+  'Asia/Hebron',
+  'Asia/Ho_Chi_Minh',
+  'Asia/Hong_Kong',
+  'Asia/Hovd',
+  'Asia/Irkutsk',
+  'Asia/Jakarta',
+  'Asia/Jayapura',
+  'Asia/Jerusalem',
+  'Asia/Kabul',
+  'Asia/Kamchatka',
+  'Asia/Karachi',
+  'Asia/Kathmandu',
+  'Asia/Khandyga',
+  'Asia/Kolkata',
+  'Asia/Krasnoyarsk',
+  'Asia/Kuching',
+  'Asia/Macau',
+  'Asia/Magadan',
+  'Asia/Makassar',
+  'Asia/Manila',
+  'Asia/Nicosia',
+  'Asia/Novokuznetsk',
+  'Asia/Novosibirsk',
+  'Asia/Omsk',
+  'Asia/Oral',
+  'Asia/Pontianak',
+  'Asia/Pyongyang',
+  'Asia/Qatar',
+  'Asia/Qostanay',
+  'Asia/Qyzylorda',
+  'Asia/Riyadh',
+  'Asia/Sakhalin',
+  'Asia/Samarkand',
+  'Asia/Seoul',
+  'Asia/Shanghai',
+  'Asia/Singapore',
+  'Asia/Srednekolymsk',
+  'Asia/Taipei',
+  'Asia/Tashkent',
+  'Asia/Tbilisi',
+  'Asia/Tehran',
+  'Asia/Thimphu',
+  'Asia/Tokyo',
+  'Asia/Tomsk',
+  'Asia/Ulaanbaatar',
+  'Asia/Urumqi',
+  'Asia/Ust-Nera',
+  'Asia/Vladivostok',
+  'Asia/Yakutsk',
+  'Asia/Yangon',
+  'Asia/Yekaterinburg',
+  'Asia/Yerevan',
+  'Atlantic/Azores',
+  'Atlantic/Bermuda',
+  'Atlantic/Canary',
+  'Atlantic/Cape_Verde',
+  'Atlantic/Faroe',
+  'Atlantic/Madeira',
+  'Atlantic/South_Georgia',
+  'Atlantic/Stanley',
+  'Australia/Adelaide',
+  'Australia/Brisbane',
+  'Australia/Broken_Hill',
+  'Australia/Darwin',
+  'Australia/Eucla',
+  'Australia/Hobart',
+  'Australia/Lindeman',
+  'Australia/Lord_Howe',
+  'Australia/Melbourne',
+  'Australia/Perth',
+  'Australia/Sydney',
+  'CET',
+  'CST6CDT',
+  'EET',
+  'EST',
+  'EST5EDT',
+  'Etc/GMT',
+  'Etc/GMT+1',
+  'Etc/GMT+10',
+  'Etc/GMT+11',
+  'Etc/GMT+12',
+  'Etc/GMT+2',
+  'Etc/GMT+3',
+  'Etc/GMT+4',
+  'Etc/GMT+5',
+  'Etc/GMT+6',
+  'Etc/GMT+7',
+  'Etc/GMT+8',
+  'Etc/GMT+9',
+  'Etc/GMT-1',
+  'Etc/GMT-10',
+  'Etc/GMT-11',
+  'Etc/GMT-12',
+  'Etc/GMT-13',
+  'Etc/GMT-14',
+  'Etc/GMT-2',
+  'Etc/GMT-3',
+  'Etc/GMT-4',
+  'Etc/GMT-5',
+  'Etc/GMT-6',
+  'Etc/GMT-7',
+  'Etc/GMT-8',
+  'Etc/GMT-9',
+  'Etc/UTC',
+  'Europe/Andorra',
+  'Europe/Astrakhan',
+  'Europe/Athens',
+  'Europe/Belgrade',
+  'Europe/Berlin',
+  'Europe/Brussels',
+  'Europe/Bucharest',
+  'Europe/Budapest',
+  'Europe/Chisinau',
+  'Europe/Dublin',
+  'Europe/Gibraltar',
+  'Europe/Helsinki',
+  'Europe/Istanbul',
+  'Europe/Kaliningrad',
+  'Europe/Kirov',
+  'Europe/Kyiv',
+  'Europe/Lisbon',
+  'Europe/London',
+  'Europe/Madrid',
+  'Europe/Malta',
+  'Europe/Minsk',
+  'Europe/Moscow',
+  'Europe/Paris',
+  'Europe/Prague',
+  'Europe/Riga',
+  'Europe/Rome',
+  'Europe/Samara',
+  'Europe/Saratov',
+  'Europe/Simferopol',
+  'Europe/Sofia',
+  'Europe/Tallinn',
+  'Europe/Tirane',
+  'Europe/Ulyanovsk',
+  'Europe/Vienna',
+  'Europe/Vilnius',
+  'Europe/Volgograd',
+  'Europe/Warsaw',
+  'Europe/Zurich',
+  'HST',
+  'Indian/Chagos',
+  'Indian/Maldives',
+  'Indian/Mauritius',
+  'MET',
+  'MST',
+  'MST7MDT',
+  'PST8PDT',
+  'Pacific/Apia',
+  'Pacific/Auckland',
+  'Pacific/Bougainville',
+  'Pacific/Chatham',
+  'Pacific/Easter',
+  'Pacific/Efate',
+  'Pacific/Fakaofo',
+  'Pacific/Fiji',
+  'Pacific/Galapagos',
+  'Pacific/Gambier',
+  'Pacific/Guadalcanal',
+  'Pacific/Guam',
+  'Pacific/Honolulu',
+  'Pacific/Kanton',
+  'Pacific/Kiritimati',
+  'Pacific/Kosrae',
+  'Pacific/Kwajalein',
+  'Pacific/Marquesas',
+  'Pacific/Nauru',
+  'Pacific/Niue',
+  'Pacific/Norfolk',
+  'Pacific/Noumea',
+  'Pacific/Pago_Pago',
+  'Pacific/Palau',
+  'Pacific/Pitcairn',
+  'Pacific/Port_Moresby',
+  'Pacific/Rarotonga',
+  'Pacific/Tahiti',
+  'Pacific/Tarawa',
+  'Pacific/Tongatapu',
+
+  // IANA TZDB Link names
+  'WET',
+  'Africa/Accra',
+  'Africa/Addis_Ababa',
+  'Africa/Asmara',
+  'Africa/Asmera',
+  'Africa/Bamako',
+  'Africa/Bangui',
+  'Africa/Banjul',
+  'Africa/Blantyre',
+  'Africa/Brazzaville',
+  'Africa/Bujumbura',
+  'Africa/Conakry',
+  'Africa/Dakar',
+  'Africa/Dar_es_Salaam',
+  'Africa/Djibouti',
+  'Africa/Douala',
+  'Africa/Freetown',
+  'Africa/Gaborone',
+  'Africa/Harare',
+  'Africa/Kampala',
+  'Africa/Kigali',
+  'Africa/Kinshasa',
+  'Africa/Libreville',
+  'Africa/Lome',
+  'Africa/Luanda',
+  'Africa/Lubumbashi',
+  'Africa/Lusaka',
+  'Africa/Malabo',
+  'Africa/Maseru',
+  'Africa/Mbabane',
+  'Africa/Mogadishu',
+  'Africa/Niamey',
+  'Africa/Nouakchott',
+  'Africa/Ouagadougou',
+  'Africa/Porto-Novo',
+  'Africa/Timbuktu',
+  'America/Anguilla',
+  'America/Antigua',
+  'America/Argentina/ComodRivadavia',
+  'America/Aruba',
+  'America/Atikokan',
+  'America/Atka',
+  'America/Blanc-Sablon',
+  'America/Buenos_Aires',
+  'America/Catamarca',
+  'America/Cayman',
+  'America/Coral_Harbour',
+  'America/Cordoba',
+  'America/Creston',
+  'America/Curacao',
+  'America/Dominica',
+  'America/Ensenada',
+  'America/Fort_Wayne',
+  'America/Godthab',
+  'America/Grenada',
+  'America/Guadeloupe',
+  'America/Indianapolis',
+  'America/Jujuy',
+  'America/Knox_IN',
+  'America/Kralendijk',
+  'America/Louisville',
+  'America/Lower_Princes',
+  'America/Marigot',
+  'America/Mendoza',
+  'America/Montreal',
+  'America/Montserrat',
+  'America/Nassau',
+  'America/Nipigon',
+  'America/Pangnirtung',
+  'America/Port_of_Spain',
+  'America/Porto_Acre',
+  'America/Rainy_River',
+  'America/Rosario',
+  'America/Santa_Isabel',
+  'America/Shiprock',
+  'America/St_Barthelemy',
+  'America/St_Kitts',
+  'America/St_Lucia',
+  'America/St_Thomas',
+  'America/St_Vincent',
+  'America/Thunder_Bay',
+  'America/Tortola',
+  'America/Virgin',
+  'Antarctica/DumontDUrville',
+  'Antarctica/McMurdo',
+  'Antarctica/South_Pole',
+  'Antarctica/Syowa',
+  'Antarctica/Vostok',
+  'Arctic/Longyearbyen',
+  'Asia/Aden',
+  'Asia/Ashkhabad',
+  'Asia/Bahrain',
+  'Asia/Brunei',
+  'Asia/Calcutta',
+  'Asia/Chongqing',
+  'Asia/Chungking',
+  'Asia/Dacca',
+  'Asia/Harbin',
+  'Asia/Istanbul',
+  'Asia/Kashgar',
+  'Asia/Katmandu',
+  'Asia/Kuala_Lumpur',
+  'Asia/Kuwait',
+  'Asia/Macao',
+  'Asia/Muscat',
+  'Asia/Phnom_Penh',
+  'Asia/Rangoon',
+  'Asia/Saigon',
+  'Asia/Tel_Aviv',
+  'Asia/Thimbu',
+  'Asia/Ujung_Pandang',
+  'Asia/Ulan_Bator',
+  'Asia/Vientiane',
+  'Atlantic/Faeroe',
+  'Atlantic/Jan_Mayen',
+  'Atlantic/Reykjavik',
+  'Atlantic/St_Helena',
+  'Australia/ACT',
+  'Australia/Canberra',
+  'Australia/Currie',
+  'Australia/LHI',
+  'Australia/NSW',
+  'Australia/North',
+  'Australia/Queensland',
+  'Australia/South',
+  'Australia/Tasmania',
+  'Australia/Victoria',
+  'Australia/West',
+  'Australia/Yancowinna',
+  'Brazil/Acre',
+  'Brazil/DeNoronha',
+  'Brazil/East',
+  'Brazil/West',
+  'Canada/Atlantic',
+  'Canada/Central',
+  'Canada/Eastern',
+  'Canada/Mountain',
+  'Canada/Newfoundland',
+  'Canada/Pacific',
+  'Canada/Saskatchewan',
+  'Canada/Yukon',
+  'Chile/Continental',
+  'Chile/EasterIsland',
+  'Cuba',
+  'Egypt',
+  'Eire',
+  'Etc/GMT+0',
+  'Etc/GMT-0',
+  'Etc/GMT0',
+  'Etc/Greenwich',
+  'Etc/UCT',
+  'Etc/Universal',
+  'Etc/Zulu',
+  'Europe/Amsterdam',
+  'Europe/Belfast',
+  'Europe/Bratislava',
+  'Europe/Busingen',
+  'Europe/Copenhagen',
+  'Europe/Guernsey',
+  'Europe/Isle_of_Man',
+  'Europe/Jersey',
+  'Europe/Kiev',
+  'Europe/Ljubljana',
+  'Europe/Luxembourg',
+  'Europe/Mariehamn',
+  'Europe/Monaco',
+  'Europe/Nicosia',
+  'Europe/Oslo',
+  'Europe/Podgorica',
+  'Europe/San_Marino',
+  'Europe/Sarajevo',
+  'Europe/Skopje',
+  'Europe/Stockholm',
+  'Europe/Tiraspol',
+  'Europe/Uzhgorod',
+  'Europe/Vaduz',
+  'Europe/Vatican',
+  'Europe/Zagreb',
+  'Europe/Zaporozhye',
+  'GB',
+  'GB-Eire',
+  'GMT',
+  'GMT+0',
+  'GMT-0',
+  'GMT0',
+  'Greenwich',
+  'Hongkong',
+  'Iceland',
+  'Indian/Antananarivo',
+  'Indian/Christmas',
+  'Indian/Cocos',
+  'Indian/Comoro',
+  'Indian/Kerguelen',
+  'Indian/Mahe',
+  'Indian/Mayotte',
+  'Indian/Reunion',
+  'Iran',
+  'Israel',
+  'Jamaica',
+  'Japan',
+  'Kwajalein',
+  'Libya',
+  'Mexico/BajaNorte',
+  'Mexico/BajaSur',
+  'Mexico/General',
+  'NZ',
+  'NZ-CHAT',
+  'Navajo',
+  'PRC',
+  'Pacific/Chuuk',
+  'Pacific/Enderbury',
+  'Pacific/Funafuti',
+  'Pacific/Johnston',
+  'Pacific/Majuro',
+  'Pacific/Midway',
+  'Pacific/Pohnpei',
+  'Pacific/Ponape',
+  'Pacific/Saipan',
+  'Pacific/Samoa',
+  'Pacific/Truk',
+  'Pacific/Wake',
+  'Pacific/Wallis',
+  'Pacific/Yap',
+  'Poland',
+  'Portugal',
+  'ROC',
+  'ROK',
+  'Singapore',
+  'Turkey',
+  'UCT',
+  'US/Alaska',
+  'US/Aleutian',
+  'US/Arizona',
+  'US/Central',
+  'US/East-Indiana',
+  'US/Eastern',
+  'US/Hawaii',
+  'US/Indiana-Starke',
+  'US/Michigan',
+  'US/Mountain',
+  'US/Pacific',
+  'US/Samoa',
+  'UTC',
+  'Universal',
+  'W-SU',
+  'Zulu'
+];
+
+// We want to test all available named time zone identifiers (both primary and non-primary),
+// but no ECMAScript built-in API exposes that list. So we use a union of two sources:
+// 1. A hard-coded list of Zone and Link identifiers from the 2022g version of IANA TZDB.
+// 2. Canonical IDs exposed by Intl.supportedValuesOf('timeZone'), which ensures that IDs
+//    added to TZDB later than 2022g will be tested. (New IDs are almost always added as primary.)
+const ids = [...new Set([...timeZoneIdentifiers, ...Intl.supportedValuesOf('timeZone')])];
+for (const id of ids) {
+  const lower = id.toLowerCase();
+  const upper = id.toUpperCase();
+  const tz = new Temporal.TimeZone(id);
+  assert.sameValue(tz.equals(upper), true, `Time zone "${id}" compared to string "${upper}"`);
+  assert.sameValue(tz.equals(lower), true, `Time zone "${id}" compared to string "${lower}"`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getInstantFor/browser.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getInstantFor/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getInstantFor/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getInstantFor/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getInstantFor/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..0c644cf356
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getInstantFor/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.timezone.prototype.getinstantfor
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.TimeZone("UTC");
+const base = { era: "ad", month: 5, day: 2, hour: 15, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.getInstantFor({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.getInstantFor({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getInstantFor/shell.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getInstantFor/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getInstantFor/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/browser.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/shell.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/subtract-second-and-nanosecond-from-last-transition.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/subtract-second-and-nanosecond-from-last-transition.js
new file mode 100644
index 0000000000..b1b157afb4
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/subtract-second-and-nanosecond-from-last-transition.js
@@ -0,0 +1,58 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.prototype.getnexttransition
+description: >
+  Compute next transition when seconds resp. nanoseconds are subtracted from the last transition.
+features: [Temporal]
+---*/
+
+// From <https://github.com/eggert/tz/blob/main/europe>:
+//
+// # Zone  NAME       STDOFF  RULES FORMAT  [UNTIL]
+// Zone  Europe/Paris 0:09:21 -     LMT     1891 Mar 15  0:01
+//                    0:09:21 -     PMT     1911 Mar 11  0:01 # Paris MT
+
+let tz = new Temporal.TimeZone("Europe/Paris");
+
+let zdt = new Temporal.PlainDateTime(1800, 1, 1).toZonedDateTime(tz);
+assert.sameValue(zdt.toString(), "1800-01-01T00:00:00+00:09[Europe/Paris]");
+assert.sameValue(zdt.offsetNanoseconds, (9 * 60 + 21) * 1_000_000_000);
+
+// Ensure the first transition was correctly computed.
+let first = tz.getNextTransition(zdt);
+assert.sameValue(first.toString(), "1911-03-10T23:50:39Z");
+assert.sameValue(new Temporal.ZonedDateTime(first.epochNanoseconds, tz).toString(),
+                 "1911-03-10T23:50:39+00:00[Europe/Paris]");
+
+let next;
+
+// Compute the next transition starting from the first transition minus 1s.
+let firstMinus1s = first.add({seconds: -1});
+assert.sameValue(firstMinus1s.toString(), "1911-03-10T23:50:38Z");
+assert.sameValue(new Temporal.ZonedDateTime(firstMinus1s.epochNanoseconds, tz).toString(),
+                 "1911-03-10T23:59:59+00:09[Europe/Paris]");
+assert.sameValue(new Temporal.ZonedDateTime(firstMinus1s.epochNanoseconds, tz).offsetNanoseconds,
+                 (9 * 60 + 21) * 1_000_000_000);
+
+next = tz.getNextTransition(firstMinus1s);
+assert.sameValue(next.toString(), "1911-03-10T23:50:39Z");
+assert.sameValue(new Temporal.ZonedDateTime(next.epochNanoseconds, tz).toString(),
+                 "1911-03-10T23:50:39+00:00[Europe/Paris]");
+
+// Compute the next transition starting from the first transition minus 1ns.
+let firstMinus1ns = first.add({nanoseconds: -1});
+assert.sameValue(firstMinus1ns.toString(), "1911-03-10T23:50:38.999999999Z");
+assert.sameValue(new Temporal.ZonedDateTime(firstMinus1ns.epochNanoseconds, tz).toString(),
+                 "1911-03-10T23:59:59.999999999+00:09[Europe/Paris]");
+assert.sameValue(new Temporal.ZonedDateTime(firstMinus1ns.epochNanoseconds, tz).offsetNanoseconds,
+                 (9 * 60 + 21) * 1_000_000_000);
+
+next = tz.getNextTransition(firstMinus1ns);
+assert.sameValue(next.toString(), "1911-03-10T23:50:39Z");
+assert.sameValue(new Temporal.ZonedDateTime(next.epochNanoseconds, tz).toString(),
+                 "1911-03-10T23:50:39+00:00[Europe/Paris]");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/transition-at-instant-boundaries.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/transition-at-instant-boundaries.js
new file mode 100644
index 0000000000..6eb8645589
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getNextTransition/transition-at-instant-boundaries.js
@@ -0,0 +1,29 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.prototype.getnexttransition
+description: >
+  Test transitions at the instant boundaries.
+features: [Temporal, Intl-enumeration]
+---*/
+
+const min = new Temporal.Instant(-86_40000_00000_00000_00000n);
+const max = new Temporal.Instant(86_40000_00000_00000_00000n);
+
+for (let id of Intl.supportedValuesOf("timeZone")) {
+  let tz = new Temporal.TimeZone(id);
+
+  // If there's any next transition, it should be after |min|.
+  let next = tz.getNextTransition(min);
+  if (next) {
+    assert(next.epochNanoseconds > min.epochNanoseconds);
+  }
+
+  // There shouldn't be any next transition after |max|.
+  next = tz.getNextTransition(max);
+  assert.sameValue(next, null);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/browser.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/instant-string.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/instant-string.js
new file mode 100644
index 0000000000..943fb73750
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/instant-string.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.prototype.getoffsetnanosecondsfor
+description: Conversion of ISO date-time strings to Temporal.Instant instances
+features: [Temporal]
+---*/
+
+const instance = new Temporal.TimeZone("America/Vancouver");
+
+let str = "1970-01-01T00:00";
+assert.throws(RangeError, () => instance.getOffsetNanosecondsFor(str), "bare date-time string is not an instant");
+str = "1970-01-01T00:00[America/Vancouver]";
+assert.throws(RangeError, () => instance.getOffsetNanosecondsFor(str), "date-time + IANA annotation is not an instant");
+
+// The following are all valid strings so should not throw:
+
+const valids = [
+  "1970-01-01T00:00Z",
+  "1970-01-01T00:00+01:00",
+  "1970-01-01T00:00Z[America/Vancouver]",
+  "1970-01-01T00:00+01:00[America/Vancouver]",
+];
+for (const str of valids) {
+  const result = instance.getOffsetNanosecondsFor(str);
+  assert.sameValue(result, -28800e9);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/nanoseconds-subtracted-or-added-at-dst-transition.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/nanoseconds-subtracted-or-added-at-dst-transition.js
new file mode 100644
index 0000000000..06b28bf8f7
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/nanoseconds-subtracted-or-added-at-dst-transition.js
@@ -0,0 +1,40 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.prototype.getoffsetnanosecondsfor
+description: >
+  Test offset when nanoseconds are subtracted or added from DST transition.
+features: [Temporal, exponentiation]
+---*/
+
+// From <https://github.com/eggert/tz/blob/main/northamerica>:
+//
+// # Rule  NAME  FROM  TO    -  IN   ON       AT    SAVE  LETTER
+// Rule    CA    1950  1966  -  Apr  lastSun  1:00  1:00  D
+//
+// # Zone  NAME             STDOFF    RULES  FORMAT  [UNTIL]
+// Zone America/Los_Angeles -7:52:58  -      LMT     1883 Nov 18 12:07:02
+//                          -8:00     US     P%sT    1946
+//                          -8:00     CA     P%sT    1967
+//                          -8:00     US     P%sT
+
+let tz = new Temporal.TimeZone("America/Los_Angeles");
+let p = Temporal.Instant.from("1965-04-25T09:00:00Z");
+
+const nsPerHour = 60 * 60 * 1000**3;
+
+assert.sameValue(tz.getOffsetNanosecondsFor(p),
+                 -7 * nsPerHour,
+                 "DST transition");
+
+assert.sameValue(tz.getOffsetNanosecondsFor(p.add({nanoseconds: +1})),
+                 -7 * nsPerHour,
+                 "DST transition plus one nanosecond");
+
+assert.sameValue(tz.getOffsetNanosecondsFor(p.add({nanoseconds: -1})),
+                 -8 * nsPerHour,
+                 "DST transition minus one nanosecond");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/shell.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetNanosecondsFor/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetStringFor/browser.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetStringFor/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetStringFor/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetStringFor/instant-string.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetStringFor/instant-string.js
new file mode 100644
index 0000000000..4454bd6eb3
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetStringFor/instant-string.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.prototype.getoffsetstringfor
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances
+features: [Temporal]
+---*/
+
+const instance = new Temporal.TimeZone("America/Vancouver");
+
+let str = "1970-01-01T00:00";
+assert.throws(RangeError, () => instance.getOffsetStringFor(str), "bare date-time string is not an instant");
+str = "1970-01-01T00:00[America/Vancouver]";
+assert.throws(RangeError, () => instance.getOffsetStringFor(str), "date-time + IANA annotation is not an instant");
+
+// The following are all valid strings so should not throw:
+
+const valids = [
+  "1970-01-01T00:00Z",
+  "1970-01-01T00:00+01:00",
+  "1970-01-01T00:00Z[America/Vancouver]",
+  "1970-01-01T00:00+01:00[America/Vancouver]",
+];
+for (const str of valids) {
+  const result = instance.getOffsetStringFor(str);
+  assert.sameValue(result, "-08:00");
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetStringFor/shell.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetStringFor/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getOffsetStringFor/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/basic.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/basic.js
new file mode 100644
index 0000000000..c10f4676c4
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/basic.js
@@ -0,0 +1,81 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.prototype.getplaindatetimefor
+description: Sample of results for IANA time zones
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+function test(epochNs, results) {
+  const instant = new Temporal.Instant(epochNs);
+  Object.entries(results).forEach(([id, expected]) => {
+    const tz = new Temporal.TimeZone(id);
+    const dt = tz.getPlainDateTimeFor(instant);
+    TemporalHelpers.assertPlainDateTime(dt, ...expected, `Local time of ${instant} in ${id}`);
+  });
+}
+
+// Unix epoch
+test(0n, {
+  'America/Los_Angeles': [1969, 12, "M12", 31, 16, 0, 0, 0, 0, 0],
+  'America/New_York': [1969, 12, "M12", 31, 19, 0, 0, 0, 0, 0],
+  'Africa/Monrovia': [1969, 12, "M12", 31, 23, 15, 30, 0, 0, 0],
+  'Europe/London': [1970, 1, "M01", 1, 1, 0, 0, 0, 0, 0],
+  'Europe/Berlin': [1970, 1, "M01", 1, 1, 0, 0, 0, 0, 0],
+  'Europe/Moscow': [1970, 1, "M01", 1, 3, 0, 0, 0, 0, 0],
+  'Asia/Kolkata': [1970, 1, "M01", 1, 5, 30, 0, 0, 0, 0],
+  'Asia/Tokyo': [1970, 1, "M01", 1, 9, 0, 0, 0, 0, 0],
+});
+
+// Just before epoch
+test(-1n, {
+  'America/Los_Angeles': [1969, 12, "M12", 31, 15, 59, 59, 999, 999, 999],
+  'America/New_York': [1969, 12, "M12", 31, 18, 59, 59, 999, 999, 999],
+  'Africa/Monrovia': [1969, 12, "M12", 31, 23, 15, 29, 999, 999, 999],
+  'Europe/London': [1970, 1, "M01", 1, 0, 59, 59, 999, 999, 999],
+  'Europe/Berlin': [1970, 1, "M01", 1, 0, 59, 59, 999, 999, 999],
+  'Europe/Moscow': [1970, 1, "M01", 1, 2, 59, 59, 999, 999, 999],
+  'Asia/Kolkata': [1970, 1, "M01", 1, 5, 29, 59, 999, 999, 999],
+  'Asia/Tokyo': [1970, 1, "M01", 1, 8, 59, 59, 999, 999, 999],
+});
+
+// Just after epoch
+test(1n, {
+  'America/Los_Angeles': [1969, 12, "M12", 31, 16, 0, 0, 0, 0, 1],
+  'America/New_York': [1969, 12, "M12", 31, 19, 0, 0, 0, 0, 1],
+  'Africa/Monrovia': [1969, 12, "M12", 31, 23, 15, 30, 0, 0, 1],
+  'Europe/London': [1970, 1, "M01", 1, 1, 0, 0, 0, 0, 1],
+  'Europe/Berlin': [1970, 1, "M01", 1, 1, 0, 0, 0, 0, 1],
+  'Europe/Moscow': [1970, 1, "M01", 1, 3, 0, 0, 0, 0, 1],
+  'Asia/Kolkata': [1970, 1, "M01", 1, 5, 30, 0, 0, 0, 1],
+  'Asia/Tokyo': [1970, 1, "M01", 1, 9, 0, 0, 0, 0, 1],
+});
+
+// Hours before epoch
+test(-6300_000_000_001n, {
+  'America/Los_Angeles': [1969, 12, "M12", 31, 14, 14, 59, 999, 999, 999],
+  'America/New_York': [1969, 12, "M12", 31, 17, 14, 59, 999, 999, 999],
+  'Africa/Monrovia': [1969, 12, "M12", 31, 21, 30, 29, 999, 999, 999],
+  'Europe/London': [1969, 12, "M12", 31, 23, 14, 59, 999, 999, 999],
+  'Europe/Berlin': [1969, 12, "M12", 31, 23, 14, 59, 999, 999, 999],
+  'Europe/Moscow': [1970, 1, "M01", 1, 1, 14, 59, 999, 999, 999],
+  'Asia/Kolkata': [1970, 1, "M01", 1, 3, 44, 59, 999, 999, 999],
+  'Asia/Tokyo': [1970, 1, "M01", 1, 7, 14, 59, 999, 999, 999],
+});
+
+// Hours after epoch
+test(6300_000_000_001n, {
+  'America/Los_Angeles': [1969, 12, "M12", 31, 17, 45, 0, 0, 0, 1],
+  'America/New_York': [1969, 12, "M12", 31, 20, 45, 0, 0, 0, 1],
+  'Africa/Monrovia': [1970, 1, "M01", 1, 1, 0, 30, 0, 0, 1],
+  'Europe/London': [1970, 1, "M01", 1, 2, 45, 0, 0, 0, 1],
+  'Europe/Berlin': [1970, 1, "M01", 1, 2, 45, 0, 0, 0, 1],
+  'Europe/Moscow': [1970, 1, "M01", 1, 4, 45, 0, 0, 0, 1],
+  'Asia/Kolkata': [1970, 1, "M01", 1, 7, 15, 0, 0, 0, 1],
+  'Asia/Tokyo': [1970, 1, "M01", 1, 10, 45, 0, 0, 0, 1],
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/browser.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/dst.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/dst.js
new file mode 100644
index 0000000000..4fb19513d4
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/dst.js
@@ -0,0 +1,28 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.prototype.getplaindatetimefor
+description: Sample of results for IANA time zones around DST changes
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+function test(epochNs, id, expected) {
+  const instant = new Temporal.Instant(epochNs);
+  const tz = new Temporal.TimeZone(id);
+  const dt = tz.getPlainDateTimeFor(instant);
+  TemporalHelpers.assertPlainDateTime(dt, ...expected, `Local time of ${instant} in ${id}`);
+}
+
+// Just before DST forward shift
+test(1553993999_999_999_999n, "Europe/London", [2019, 3, "M03", 31, 0, 59, 59, 999, 999, 999]);
+// Just after DST forward shift
+test(1553994000_000_000_000n, "Europe/London", [2019, 3, "M03", 31, 2, 0, 0, 0, 0, 0]);
+// Just before DST backward shift
+test(1550368799_999_999_999n, "America/Sao_Paulo", [2019, 2, "M02", 16, 23, 59, 59, 999, 999, 999]);
+// Just after DST backward shift
+test(1550368800_000_000_000n, "America/Sao_Paulo", [2019, 2, "M02", 16, 23, 0, 0, 0, 0, 0]);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/instant-string.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/instant-string.js
new file mode 100644
index 0000000000..57cd6423c2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/instant-string.js
@@ -0,0 +1,35 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.prototype.getplaindatetimefor
+description: Conversion of ISO date-time strings to Temporal.Instant instances
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.TimeZone("America/Vancouver");
+
+let str = "1970-01-01T00:00";
+assert.throws(RangeError, () => instance.getPlainDateTimeFor(str), "bare date-time string is not an instant");
+str = "1970-01-01T00:00[America/Vancouver]";
+assert.throws(RangeError, () => instance.getPlainDateTimeFor(str), "date-time + IANA annotation is not an instant");
+
+str = "1970-01-01T00:00Z";
+const result1 = instance.getPlainDateTimeFor(str);
+TemporalHelpers.assertPlainDateTime(result1, 1969, 12, "M12", 31, 16, 0, 0, 0, 0, 0, "date-time + Z preserves exact time");
+
+str = "1970-01-01T00:00+01:00";
+const result2 = instance.getPlainDateTimeFor(str);
+TemporalHelpers.assertPlainDateTime(result2, 1969, 12, "M12", 31, 15, 0, 0, 0, 0, 0, "date-time + offset preserves exact time with offset");
+
+str = "1970-01-01T00:00Z[America/Vancouver]";
+const result3 = instance.getPlainDateTimeFor(str);
+TemporalHelpers.assertPlainDateTime(result3, 1969, 12, "M12", 31, 16, 0, 0, 0, 0, 0, "date-time + Z + IANA annotation ignores the IANA annotation");
+
+str = "1970-01-01T00:00+01:00[America/Vancouver]";
+const result4 = instance.getPlainDateTimeFor(str);
+TemporalHelpers.assertPlainDateTime(result4, 1969, 12, "M12", 31, 15, 0, 0, 0, 0, 0, "date-time + offset + IANA annotation ignores the IANA annotation");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/shell.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPlainDateTimeFor/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPossibleInstantsFor/browser.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPossibleInstantsFor/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPossibleInstantsFor/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPossibleInstantsFor/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPossibleInstantsFor/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..017b61be76
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPossibleInstantsFor/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.timezone.prototype.getpossibleinstantsfor
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.TimeZone("UTC");
+const base = { era: "ad", month: 5, day: 2, hour: 15, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.getPossibleInstantsFor({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.getPossibleInstantsFor({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPossibleInstantsFor/shell.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPossibleInstantsFor/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPossibleInstantsFor/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/browser.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/nanoseconds-subtracted-or-added-at-dst-transition.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/nanoseconds-subtracted-or-added-at-dst-transition.js
new file mode 100644
index 0000000000..1e978d0936
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/nanoseconds-subtracted-or-added-at-dst-transition.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.prototype.getprevioustransition
+description: >
+  Test previous transition when nanoseconds are subtracted resp. added to the DST transition.
+features: [Temporal]
+---*/
+
+let tz = new Temporal.TimeZone("Europe/Berlin");
+let p = Temporal.Instant.from("2021-03-28T01:00:00Z");
+
+assert.sameValue(tz.getPreviousTransition(p.add({nanoseconds: -1})).toString(),
+                 "2020-10-25T01:00:00Z",
+                 "DST transition minus one nanosecond");
+
+assert.sameValue(tz.getPreviousTransition(p).toString(),
+                 "2020-10-25T01:00:00Z",
+                 "DST transition");
+
+assert.sameValue(tz.getPreviousTransition(p.add({nanoseconds: +1})).toString(),
+                 "2021-03-28T01:00:00Z",
+                 "DST transition plus one nanosecond");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/shell.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/transition-at-instant-boundaries.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/transition-at-instant-boundaries.js
new file mode 100644
index 0000000000..21c4da725b
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/getPreviousTransition/transition-at-instant-boundaries.js
@@ -0,0 +1,29 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone.prototype.getprevioustransition
+description: >
+  Test transitions at the instant boundaries.
+features: [Temporal, Intl-enumeration]
+---*/
+
+const min = new Temporal.Instant(-86_40000_00000_00000_00000n);
+const max = new Temporal.Instant(86_40000_00000_00000_00000n);
+
+for (let id of Intl.supportedValuesOf("timeZone")) {
+  let tz = new Temporal.TimeZone(id);
+
+  // If there's any previous transition, it should be before |max|.
+  let prev = tz.getPreviousTransition(max);
+  if (prev) {
+    assert(prev.epochNanoseconds < max.epochNanoseconds);
+  }
+
+  // There shouldn't be any previous transition before |min|.
+  prev = tz.getPreviousTransition(min);
+  assert.sameValue(prev, null);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/shell.js b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/prototype/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/shell.js b/js/src/tests/test262/intl402/Temporal/TimeZone/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/supported-values-of.js b/js/src/tests/test262/intl402/Temporal/TimeZone/supported-values-of.js
new file mode 100644
index 0000000000..c8ea68cfa4
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/supported-values-of.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: >
+  TimeZone constructor accepts all time zone identifiers from Intl.supportedValuesOf.
+features: [Temporal, Intl-enumeration]
+---*/
+
+// Ensure all identifiers are valid and canonical.
+for (let id of Intl.supportedValuesOf("timeZone")) {
+  let tz = new Temporal.TimeZone(id);
+
+  assert.sameValue(tz.id, id);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/TimeZone/timezone-case-insensitive.js b/js/src/tests/test262/intl402/Temporal/TimeZone/timezone-case-insensitive.js
new file mode 100644
index 0000000000..bf0b77caf7
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/TimeZone/timezone-case-insensitive.js
@@ -0,0 +1,15 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.timezone
+description: Time zone names are case insensitive
+features: [Temporal]
+---*/
+
+const timeZone = 'eTc/gMt+1';
+const result = new Temporal.TimeZone(timeZone);
+assert.sameValue(result.toString(), 'Etc/GMT+1', `Time zone created from string "${timeZone}"`);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/argument-propertybag-timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/argument-propertybag-timezone-string-datetime.js
new file mode 100644
index 0000000000..48ce8f47d9
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/argument-propertybag-timezone-string-datetime.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.compare
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+const instance = new Temporal.ZonedDateTime(1588402800_000_000_000n, "America/Vancouver")
+
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+const result1 = Temporal.ZonedDateTime.compare({ year: 2020, month: 5, day: 2, timeZone }, instance);
+assert.sameValue(result1, 0, "date-time + IANA annotation is the IANA time zone (first argument)");
+const result2 = Temporal.ZonedDateTime.compare(instance, { year: 2020, month: 5, day: 2, timeZone });
+assert.sameValue(result1, 0, "date-time + IANA annotation is the IANA time zone (second argument)");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+const result3 = Temporal.ZonedDateTime.compare({ year: 2020, month: 5, day: 2, timeZone }, instance);
+assert.sameValue(result3, 0, "date-time + Z + IANA annotation is the IANA time zone (first argument)");
+const result4 = Temporal.ZonedDateTime.compare(instance, { year: 2020, month: 5, day: 2, timeZone });
+assert.sameValue(result4, 0, "date-time + Z + IANA annotation is the IANA time zone (second argument)");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+const result5 = Temporal.ZonedDateTime.compare({ year: 2020, month: 5, day: 2, timeZone }, instance);
+assert.sameValue(result5, 0, "date-time + offset + IANA annotation is the IANA time zone (first argument)");
+const result6 = Temporal.ZonedDateTime.compare(instance, { year: 2020, month: 5, day: 2, timeZone });
+assert.sameValue(result6, 0, "date-time + offset + IANA annotation is the IANA time zone (second argument)");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..bf4aab9601
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/infinity-throws-rangeerror.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if any value in a property bag for either argument is Infinity or -Infinity
+esid: sec-temporal.zoneddatetime.compare
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const other = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "gregory");
+const base = { era: "ad", month: 5, day: 2, hour: 15, timeZone: "UTC", calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => Temporal.ZonedDateTime.compare({ ...base, eraYear: inf }, other), `eraYear property cannot be ${inf}`);
+
+  assert.throws(RangeError, () => Temporal.ZonedDateTime.compare(other, { ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls1 = [];
+  const obj1 = TemporalHelpers.toPrimitiveObserver(calls1, inf, "eraYear");
+  assert.throws(RangeError, () => Temporal.ZonedDateTime.compare({ ...base, eraYear: obj1 }, other));
+  assert.compareArray(calls1, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+
+  const calls2 = [];
+  const obj2 = TemporalHelpers.toPrimitiveObserver(calls2, inf, "eraYear");
+  assert.throws(RangeError, () => Temporal.ZonedDateTime.compare(other, { ...base, eraYear: obj2 }));
+  assert.compareArray(calls2, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/compare/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/argument-propertybag-timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/argument-propertybag-timezone-string-datetime.js
new file mode 100644
index 0000000000..810853124a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/argument-propertybag-timezone-string-datetime.js
@@ -0,0 +1,23 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.from
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+const result1 = Temporal.ZonedDateTime.from({ year: 2000, month: 5, day: 2, timeZone });
+assert.sameValue(result1.timeZoneId, "America/Vancouver", "date-time + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+const result2 = Temporal.ZonedDateTime.from({ year: 2000, month: 5, day: 2, timeZone });
+assert.sameValue(result2.timeZoneId, "America/Vancouver", "date-time + Z + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+const result3 = Temporal.ZonedDateTime.from({ year: 2000, month: 5, day: 2, timeZone });
+assert.sameValue(result3.timeZoneId, "America/Vancouver", "date-time + offset + IANA annotation is the IANA time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/do-not-canonicalize-iana-identifiers.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/do-not-canonicalize-iana-identifiers.js
new file mode 100644
index 0000000000..6e894c0f26
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/do-not-canonicalize-iana-identifiers.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.from
+description: ZonedDateTime.from does not canonicalize time zone IDs
+features: [Temporal]
+---*/
+
+const calcutta = Temporal.ZonedDateTime.from('2020-01-01T00:00:00+05:30[Asia/Calcutta]');
+const kolkata = Temporal.ZonedDateTime.from('2020-01-01T00:00:00+05:30[Asia/Kolkata]');
+
+assert.sameValue(calcutta.toString(), '2020-01-01T00:00:00+05:30[Asia/Calcutta]');
+assert.sameValue(calcutta.toJSON(), '2020-01-01T00:00:00+05:30[Asia/Calcutta]');
+assert.sameValue(calcutta.timeZoneId, 'Asia/Calcutta');
+
+assert.sameValue(kolkata.toString(), '2020-01-01T00:00:00+05:30[Asia/Kolkata]');
+assert.sameValue(kolkata.toJSON(), '2020-01-01T00:00:00+05:30[Asia/Kolkata]');
+assert.sameValue(kolkata.timeZoneId, 'Asia/Kolkata');
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..61e399957a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/infinity-throws-rangeerror.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.zoneddatetime.from
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const base = { era: "ad", month: 5, day: 2, hour: 15, timeZone: "UTC", calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  ["constrain", "reject"].forEach((overflow) => {
+    assert.throws(RangeError, () => Temporal.ZonedDateTime.from({ ...base, eraYear: inf }, { overflow }), `eraYear property cannot be ${inf} (overflow ${overflow}`);
+
+    const calls = [];
+    const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+    assert.throws(RangeError, () => Temporal.ZonedDateTime.from({ ...base, eraYear: obj }, { overflow }));
+    assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/timezone-case-insensitive.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/timezone-case-insensitive.js
new file mode 100644
index 0000000000..092e5e0be7
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/timezone-case-insensitive.js
@@ -0,0 +1,630 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.from
+description: Time zone identifiers are case-normalized
+features: [Temporal]
+---*/
+
+const timeZoneIdentifiers = [
+  // IANA TZDB Zone names
+  'Africa/Abidjan',
+  'Africa/Algiers',
+  'Africa/Bissau',
+  'Africa/Cairo',
+  'Africa/Casablanca',
+  'Africa/Ceuta',
+  'Africa/El_Aaiun',
+  'Africa/Johannesburg',
+  'Africa/Juba',
+  'Africa/Khartoum',
+  'Africa/Lagos',
+  'Africa/Maputo',
+  'Africa/Monrovia',
+  'Africa/Nairobi',
+  'Africa/Ndjamena',
+  'Africa/Sao_Tome',
+  'Africa/Tripoli',
+  'Africa/Tunis',
+  'Africa/Windhoek',
+  'America/Adak',
+  'America/Anchorage',
+  'America/Araguaina',
+  'America/Argentina/Buenos_Aires',
+  'America/Argentina/Catamarca',
+  'America/Argentina/Cordoba',
+  'America/Argentina/Jujuy',
+  'America/Argentina/La_Rioja',
+  'America/Argentina/Mendoza',
+  'America/Argentina/Rio_Gallegos',
+  'America/Argentina/Salta',
+  'America/Argentina/San_Juan',
+  'America/Argentina/San_Luis',
+  'America/Argentina/Tucuman',
+  'America/Argentina/Ushuaia',
+  'America/Asuncion',
+  'America/Bahia',
+  'America/Bahia_Banderas',
+  'America/Barbados',
+  'America/Belem',
+  'America/Belize',
+  'America/Boa_Vista',
+  'America/Bogota',
+  'America/Boise',
+  'America/Cambridge_Bay',
+  'America/Campo_Grande',
+  'America/Cancun',
+  'America/Caracas',
+  'America/Cayenne',
+  'America/Chicago',
+  'America/Chihuahua',
+  // 'America/Ciudad_Juarez' // uncomment after Node supports this ID added in TZDB 2022g
+  'America/Costa_Rica',
+  'America/Cuiaba',
+  'America/Danmarkshavn',
+  'America/Dawson',
+  'America/Dawson_Creek',
+  'America/Denver',
+  'America/Detroit',
+  'America/Edmonton',
+  'America/Eirunepe',
+  'America/El_Salvador',
+  'America/Fort_Nelson',
+  'America/Fortaleza',
+  'America/Glace_Bay',
+  'America/Goose_Bay',
+  'America/Grand_Turk',
+  'America/Guatemala',
+  'America/Guayaquil',
+  'America/Guyana',
+  'America/Halifax',
+  'America/Havana',
+  'America/Hermosillo',
+  'America/Indiana/Indianapolis',
+  'America/Indiana/Knox',
+  'America/Indiana/Marengo',
+  'America/Indiana/Petersburg',
+  'America/Indiana/Tell_City',
+  'America/Indiana/Vevay',
+  'America/Indiana/Vincennes',
+  'America/Indiana/Winamac',
+  'America/Inuvik',
+  'America/Iqaluit',
+  'America/Jamaica',
+  'America/Juneau',
+  'America/Kentucky/Louisville',
+  'America/Kentucky/Monticello',
+  'America/La_Paz',
+  'America/Lima',
+  'America/Los_Angeles',
+  'America/Maceio',
+  'America/Managua',
+  'America/Manaus',
+  'America/Martinique',
+  'America/Matamoros',
+  'America/Mazatlan',
+  'America/Menominee',
+  'America/Merida',
+  'America/Metlakatla',
+  'America/Mexico_City',
+  'America/Miquelon',
+  'America/Moncton',
+  'America/Monterrey',
+  'America/Montevideo',
+  'America/New_York',
+  'America/Nome',
+  'America/Noronha',
+  'America/North_Dakota/Beulah',
+  'America/North_Dakota/Center',
+  'America/North_Dakota/New_Salem',
+  'America/Nuuk',
+  'America/Ojinaga',
+  'America/Panama',
+  'America/Paramaribo',
+  'America/Phoenix',
+  'America/Port-au-Prince',
+  'America/Porto_Velho',
+  'America/Puerto_Rico',
+  'America/Punta_Arenas',
+  'America/Rankin_Inlet',
+  'America/Recife',
+  'America/Regina',
+  'America/Resolute',
+  'America/Rio_Branco',
+  'America/Santarem',
+  'America/Santiago',
+  'America/Santo_Domingo',
+  'America/Sao_Paulo',
+  'America/Scoresbysund',
+  'America/Sitka',
+  'America/St_Johns',
+  'America/Swift_Current',
+  'America/Tegucigalpa',
+  'America/Thule',
+  'America/Tijuana',
+  'America/Toronto',
+  'America/Vancouver',
+  'America/Whitehorse',
+  'America/Winnipeg',
+  'America/Yakutat',
+  'America/Yellowknife',
+  'Antarctica/Casey',
+  'Antarctica/Davis',
+  'Antarctica/Macquarie',
+  'Antarctica/Mawson',
+  'Antarctica/Palmer',
+  'Antarctica/Rothera',
+  'Antarctica/Troll',
+  'Asia/Almaty',
+  'Asia/Amman',
+  'Asia/Anadyr',
+  'Asia/Aqtau',
+  'Asia/Aqtobe',
+  'Asia/Ashgabat',
+  'Asia/Atyrau',
+  'Asia/Baghdad',
+  'Asia/Baku',
+  'Asia/Bangkok',
+  'Asia/Barnaul',
+  'Asia/Beirut',
+  'Asia/Bishkek',
+  'Asia/Chita',
+  'Asia/Choibalsan',
+  'Asia/Colombo',
+  'Asia/Damascus',
+  'Asia/Dhaka',
+  'Asia/Dili',
+  'Asia/Dubai',
+  'Asia/Dushanbe',
+  'Asia/Famagusta',
+  'Asia/Gaza',
+  'Asia/Hebron',
+  'Asia/Ho_Chi_Minh',
+  'Asia/Hong_Kong',
+  'Asia/Hovd',
+  'Asia/Irkutsk',
+  'Asia/Jakarta',
+  'Asia/Jayapura',
+  'Asia/Jerusalem',
+  'Asia/Kabul',
+  'Asia/Kamchatka',
+  'Asia/Karachi',
+  'Asia/Kathmandu',
+  'Asia/Khandyga',
+  'Asia/Kolkata',
+  'Asia/Krasnoyarsk',
+  'Asia/Kuching',
+  'Asia/Macau',
+  'Asia/Magadan',
+  'Asia/Makassar',
+  'Asia/Manila',
+  'Asia/Nicosia',
+  'Asia/Novokuznetsk',
+  'Asia/Novosibirsk',
+  'Asia/Omsk',
+  'Asia/Oral',
+  'Asia/Pontianak',
+  'Asia/Pyongyang',
+  'Asia/Qatar',
+  'Asia/Qostanay',
+  'Asia/Qyzylorda',
+  'Asia/Riyadh',
+  'Asia/Sakhalin',
+  'Asia/Samarkand',
+  'Asia/Seoul',
+  'Asia/Shanghai',
+  'Asia/Singapore',
+  'Asia/Srednekolymsk',
+  'Asia/Taipei',
+  'Asia/Tashkent',
+  'Asia/Tbilisi',
+  'Asia/Tehran',
+  'Asia/Thimphu',
+  'Asia/Tokyo',
+  'Asia/Tomsk',
+  'Asia/Ulaanbaatar',
+  'Asia/Urumqi',
+  'Asia/Ust-Nera',
+  'Asia/Vladivostok',
+  'Asia/Yakutsk',
+  'Asia/Yangon',
+  'Asia/Yekaterinburg',
+  'Asia/Yerevan',
+  'Atlantic/Azores',
+  'Atlantic/Bermuda',
+  'Atlantic/Canary',
+  'Atlantic/Cape_Verde',
+  'Atlantic/Faroe',
+  'Atlantic/Madeira',
+  'Atlantic/South_Georgia',
+  'Atlantic/Stanley',
+  'Australia/Adelaide',
+  'Australia/Brisbane',
+  'Australia/Broken_Hill',
+  'Australia/Darwin',
+  'Australia/Eucla',
+  'Australia/Hobart',
+  'Australia/Lindeman',
+  'Australia/Lord_Howe',
+  'Australia/Melbourne',
+  'Australia/Perth',
+  'Australia/Sydney',
+  'CET',
+  'CST6CDT',
+  'EET',
+  'EST',
+  'EST5EDT',
+  'Etc/GMT',
+  'Etc/GMT+1',
+  'Etc/GMT+10',
+  'Etc/GMT+11',
+  'Etc/GMT+12',
+  'Etc/GMT+2',
+  'Etc/GMT+3',
+  'Etc/GMT+4',
+  'Etc/GMT+5',
+  'Etc/GMT+6',
+  'Etc/GMT+7',
+  'Etc/GMT+8',
+  'Etc/GMT+9',
+  'Etc/GMT-1',
+  'Etc/GMT-10',
+  'Etc/GMT-11',
+  'Etc/GMT-12',
+  'Etc/GMT-13',
+  'Etc/GMT-14',
+  'Etc/GMT-2',
+  'Etc/GMT-3',
+  'Etc/GMT-4',
+  'Etc/GMT-5',
+  'Etc/GMT-6',
+  'Etc/GMT-7',
+  'Etc/GMT-8',
+  'Etc/GMT-9',
+  'Etc/UTC',
+  'Europe/Andorra',
+  'Europe/Astrakhan',
+  'Europe/Athens',
+  'Europe/Belgrade',
+  'Europe/Berlin',
+  'Europe/Brussels',
+  'Europe/Bucharest',
+  'Europe/Budapest',
+  'Europe/Chisinau',
+  'Europe/Dublin',
+  'Europe/Gibraltar',
+  'Europe/Helsinki',
+  'Europe/Istanbul',
+  'Europe/Kaliningrad',
+  'Europe/Kirov',
+  'Europe/Kyiv',
+  'Europe/Lisbon',
+  'Europe/London',
+  'Europe/Madrid',
+  'Europe/Malta',
+  'Europe/Minsk',
+  'Europe/Moscow',
+  'Europe/Paris',
+  'Europe/Prague',
+  'Europe/Riga',
+  'Europe/Rome',
+  'Europe/Samara',
+  'Europe/Saratov',
+  'Europe/Simferopol',
+  'Europe/Sofia',
+  'Europe/Tallinn',
+  'Europe/Tirane',
+  'Europe/Ulyanovsk',
+  'Europe/Vienna',
+  'Europe/Vilnius',
+  'Europe/Volgograd',
+  'Europe/Warsaw',
+  'Europe/Zurich',
+  'HST',
+  'Indian/Chagos',
+  'Indian/Maldives',
+  'Indian/Mauritius',
+  'MET',
+  'MST',
+  'MST7MDT',
+  'PST8PDT',
+  'Pacific/Apia',
+  'Pacific/Auckland',
+  'Pacific/Bougainville',
+  'Pacific/Chatham',
+  'Pacific/Easter',
+  'Pacific/Efate',
+  'Pacific/Fakaofo',
+  'Pacific/Fiji',
+  'Pacific/Galapagos',
+  'Pacific/Gambier',
+  'Pacific/Guadalcanal',
+  'Pacific/Guam',
+  'Pacific/Honolulu',
+  'Pacific/Kanton',
+  'Pacific/Kiritimati',
+  'Pacific/Kosrae',
+  'Pacific/Kwajalein',
+  'Pacific/Marquesas',
+  'Pacific/Nauru',
+  'Pacific/Niue',
+  'Pacific/Norfolk',
+  'Pacific/Noumea',
+  'Pacific/Pago_Pago',
+  'Pacific/Palau',
+  'Pacific/Pitcairn',
+  'Pacific/Port_Moresby',
+  'Pacific/Rarotonga',
+  'Pacific/Tahiti',
+  'Pacific/Tarawa',
+  'Pacific/Tongatapu',
+  'WET',
+
+  // IANA TZDB Link names
+  'Africa/Accra',
+  'Africa/Addis_Ababa',
+  'Africa/Asmara',
+  'Africa/Asmera',
+  'Africa/Bamako',
+  'Africa/Bangui',
+  'Africa/Banjul',
+  'Africa/Blantyre',
+  'Africa/Brazzaville',
+  'Africa/Bujumbura',
+  'Africa/Conakry',
+  'Africa/Dakar',
+  'Africa/Dar_es_Salaam',
+  'Africa/Djibouti',
+  'Africa/Douala',
+  'Africa/Freetown',
+  'Africa/Gaborone',
+  'Africa/Harare',
+  'Africa/Kampala',
+  'Africa/Kigali',
+  'Africa/Kinshasa',
+  'Africa/Libreville',
+  'Africa/Lome',
+  'Africa/Luanda',
+  'Africa/Lubumbashi',
+  'Africa/Lusaka',
+  'Africa/Malabo',
+  'Africa/Maseru',
+  'Africa/Mbabane',
+  'Africa/Mogadishu',
+  'Africa/Niamey',
+  'Africa/Nouakchott',
+  'Africa/Ouagadougou',
+  'Africa/Porto-Novo',
+  'Africa/Timbuktu',
+  'America/Anguilla',
+  'America/Antigua',
+  'America/Argentina/ComodRivadavia',
+  'America/Aruba',
+  'America/Atikokan',
+  'America/Atka',
+  'America/Blanc-Sablon',
+  'America/Buenos_Aires',
+  'America/Catamarca',
+  'America/Cayman',
+  'America/Coral_Harbour',
+  'America/Cordoba',
+  'America/Creston',
+  'America/Curacao',
+  'America/Dominica',
+  'America/Ensenada',
+  'America/Fort_Wayne',
+  'America/Godthab',
+  'America/Grenada',
+  'America/Guadeloupe',
+  'America/Indianapolis',
+  'America/Jujuy',
+  'America/Knox_IN',
+  'America/Kralendijk',
+  'America/Louisville',
+  'America/Lower_Princes',
+  'America/Marigot',
+  'America/Mendoza',
+  'America/Montreal',
+  'America/Montserrat',
+  'America/Nassau',
+  'America/Nipigon',
+  'America/Pangnirtung',
+  'America/Port_of_Spain',
+  'America/Porto_Acre',
+  'America/Rainy_River',
+  'America/Rosario',
+  'America/Santa_Isabel',
+  'America/Shiprock',
+  'America/St_Barthelemy',
+  'America/St_Kitts',
+  'America/St_Lucia',
+  'America/St_Thomas',
+  'America/St_Vincent',
+  'America/Thunder_Bay',
+  'America/Tortola',
+  'America/Virgin',
+  'Antarctica/DumontDUrville',
+  'Antarctica/McMurdo',
+  'Antarctica/South_Pole',
+  'Antarctica/Syowa',
+  'Antarctica/Vostok',
+  'Arctic/Longyearbyen',
+  'Asia/Aden',
+  'Asia/Ashkhabad',
+  'Asia/Bahrain',
+  'Asia/Brunei',
+  'Asia/Calcutta',
+  'Asia/Chongqing',
+  'Asia/Chungking',
+  'Asia/Dacca',
+  'Asia/Harbin',
+  'Asia/Istanbul',
+  'Asia/Kashgar',
+  'Asia/Katmandu',
+  'Asia/Kuala_Lumpur',
+  'Asia/Kuwait',
+  'Asia/Macao',
+  'Asia/Muscat',
+  'Asia/Phnom_Penh',
+  'Asia/Rangoon',
+  'Asia/Saigon',
+  'Asia/Tel_Aviv',
+  'Asia/Thimbu',
+  'Asia/Ujung_Pandang',
+  'Asia/Ulan_Bator',
+  'Asia/Vientiane',
+  'Atlantic/Faeroe',
+  'Atlantic/Jan_Mayen',
+  'Atlantic/Reykjavik',
+  'Atlantic/St_Helena',
+  'Australia/ACT',
+  'Australia/Canberra',
+  'Australia/Currie',
+  'Australia/LHI',
+  'Australia/NSW',
+  'Australia/North',
+  'Australia/Queensland',
+  'Australia/South',
+  'Australia/Tasmania',
+  'Australia/Victoria',
+  'Australia/West',
+  'Australia/Yancowinna',
+  'Brazil/Acre',
+  'Brazil/DeNoronha',
+  'Brazil/East',
+  'Brazil/West',
+  'Canada/Atlantic',
+  'Canada/Central',
+  'Canada/Eastern',
+  'Canada/Mountain',
+  'Canada/Newfoundland',
+  'Canada/Pacific',
+  'Canada/Saskatchewan',
+  'Canada/Yukon',
+  'Chile/Continental',
+  'Chile/EasterIsland',
+  'Cuba',
+  'Egypt',
+  'Eire',
+  'Etc/GMT+0',
+  'Etc/GMT-0',
+  'Etc/GMT0',
+  'Etc/Greenwich',
+  'Etc/UCT',
+  'Etc/Universal',
+  'Etc/Zulu',
+  'Europe/Amsterdam',
+  'Europe/Belfast',
+  'Europe/Bratislava',
+  'Europe/Busingen',
+  'Europe/Copenhagen',
+  'Europe/Guernsey',
+  'Europe/Isle_of_Man',
+  'Europe/Jersey',
+  'Europe/Kiev',
+  'Europe/Ljubljana',
+  'Europe/Luxembourg',
+  'Europe/Mariehamn',
+  'Europe/Monaco',
+  'Europe/Nicosia',
+  'Europe/Oslo',
+  'Europe/Podgorica',
+  'Europe/San_Marino',
+  'Europe/Sarajevo',
+  'Europe/Skopje',
+  'Europe/Stockholm',
+  'Europe/Tiraspol',
+  'Europe/Uzhgorod',
+  'Europe/Vaduz',
+  'Europe/Vatican',
+  'Europe/Zagreb',
+  'Europe/Zaporozhye',
+  'GB',
+  'GB-Eire',
+  'GMT',
+  'GMT+0',
+  'GMT-0',
+  'GMT0',
+  'Greenwich',
+  'Hongkong',
+  'Iceland',
+  'Indian/Antananarivo',
+  'Indian/Christmas',
+  'Indian/Cocos',
+  'Indian/Comoro',
+  'Indian/Kerguelen',
+  'Indian/Mahe',
+  'Indian/Mayotte',
+  'Indian/Reunion',
+  'Iran',
+  'Israel',
+  'Jamaica',
+  'Japan',
+  'Kwajalein',
+  'Libya',
+  'Mexico/BajaNorte',
+  'Mexico/BajaSur',
+  'Mexico/General',
+  'NZ',
+  'NZ-CHAT',
+  'Navajo',
+  'PRC',
+  'Pacific/Chuuk',
+  'Pacific/Enderbury',
+  'Pacific/Funafuti',
+  'Pacific/Johnston',
+  'Pacific/Majuro',
+  'Pacific/Midway',
+  'Pacific/Pohnpei',
+  'Pacific/Ponape',
+  'Pacific/Saipan',
+  'Pacific/Samoa',
+  'Pacific/Truk',
+  'Pacific/Wake',
+  'Pacific/Wallis',
+  'Pacific/Yap',
+  'Poland',
+  'Portugal',
+  'ROC',
+  'ROK',
+  'Singapore',
+  'Turkey',
+  'UCT',
+  'US/Alaska',
+  'US/Aleutian',
+  'US/Arizona',
+  'US/Central',
+  'US/East-Indiana',
+  'US/Eastern',
+  'US/Hawaii',
+  'US/Indiana-Starke',
+  'US/Michigan',
+  'US/Mountain',
+  'US/Pacific',
+  'US/Pacific-New',
+  'US/Samoa',
+  'UTC',
+  'Universal',
+  'W-SU',
+  'Zulu'
+];
+
+// We want to test all available named time zone identifiers (both primary and non-primary),
+// but no ECMAScript built-in API exposes that list. So we use a union of two sources:
+// 1. A hard-coded list of Zone and Link identifiers from the 2022g version of IANA TZDB.
+// 2. Canonical IDs exposed by Intl.supportedValuesOf('timeZone'), which ensures that IDs
+//    added to TZDB later than 2022g will be tested. (New IDs are almost always added as primary.)
+const ids = [...new Set([...timeZoneIdentifiers, ...Intl.supportedValuesOf('timeZone')])];
+for (const id of ids) {
+  const lower = id.toLowerCase();
+  const upper = id.toUpperCase();
+  for (const idToTest of [id, lower, upper]) {
+    const isoString = `2020-01-01[${idToTest}]`;
+    const zdt = Temporal.ZonedDateTime.from(isoString);
+    assert.sameValue(zdt.timeZoneId, id, `Time zone created from string "${isoString}"`);
+  }
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/zoneddatetime-sub-minute-offset.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/zoneddatetime-sub-minute-offset.js
new file mode 100644
index 0000000000..70dd918151
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/from/zoneddatetime-sub-minute-offset.js
@@ -0,0 +1,106 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.from
+description: Fuzzy matching behaviour with UTC offsets in ISO 8601 strings with named time zones and offset option
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+["use", "ignore", "prefer", "reject"].forEach((offset) => {
+  const result = Temporal.ZonedDateTime.from("1970-01-01T12:00-00:44:30[Africa/Monrovia]", { offset });
+  assert.sameValue(result.epochNanoseconds, 45870_000_000_000n, `accepts the exact offset string (offset: ${offset})`);
+  assert.sameValue(result.offset, "-00:44:30", "offset property is correct");
+});
+
+["use", "ignore", "prefer", "reject"].forEach((offset) => {
+  const result = Temporal.ZonedDateTime.from("1970-01-01T12:00-00:44:30.000000000[Africa/Monrovia]", { offset });
+  assert.sameValue(
+    result.epochNanoseconds,
+    45870_000_000_000n,
+    `accepts trailing zeroes after ISO string offset (offset: ${offset})`
+  );
+  assert.sameValue(result.offset, "-00:44:30", "offset property removes trailing zeroes from input");
+});
+
+assert.throws(
+  RangeError,
+  () => Temporal.ZonedDateTime.from("1970-01-01T00:00-00:44:30[-00:45]", { offset: "reject" }),
+  "minute rounding not supported for offset time zones"
+);
+
+const str = "1970-01-01T12:00-00:45[Africa/Monrovia]";
+
+["ignore", "prefer", "reject"].forEach((offset) => {
+  const result = Temporal.ZonedDateTime.from(str, { offset });
+  assert.sameValue(
+    result.epochNanoseconds,
+    45870_000_000_000n,
+    `accepts the offset string rounded to minutes (offset=${offset})`
+  );
+  assert.sameValue(result.offset, "-00:44:30", "offset property is still the full precision");
+  TemporalHelpers.assertPlainDateTime(
+    result.toPlainDateTime(),
+    1970,
+    1,
+    "M01",
+    1,
+    12,
+    0,
+    0,
+    0,
+    0,
+    0,
+    "wall time is preserved"
+  );
+});
+
+const result = Temporal.ZonedDateTime.from(str, { offset: "use" });
+assert.sameValue(
+  result.epochNanoseconds,
+  45900_000_000_000n,
+  "prioritizes the offset string with HH:MM precision when offset=use"
+);
+assert.sameValue(result.offset, "-00:44:30", "offset property is still the full precision");
+TemporalHelpers.assertPlainDateTime(
+  result.toPlainDateTime(),
+  1970,
+  1,
+  "M01",
+  1,
+  12,
+  0,
+  30,
+  0,
+  0,
+  0,
+  "wall time is shifted by the difference between exact and rounded offset"
+);
+
+const properties = { year: 1970, month: 1, day: 1, hour: 12, offset: "-00:45", timeZone: "Africa/Monrovia" };
+
+["ignore", "prefer"].forEach((offset) => {
+  const result = Temporal.ZonedDateTime.from(properties, { offset });
+  assert.sameValue(
+    result.epochNanoseconds,
+    45870_000_000_000n,
+    `no fuzzy matching is done on offset in property bag (offset=${offset})`
+  );
+});
+
+const result2 = Temporal.ZonedDateTime.from(properties, { offset: "use" });
+assert.sameValue(
+  result2.epochNanoseconds,
+  45900_000_000_000n,
+  "no fuzzy matching is done on offset in property bag (offset=use)"
+);
+
+assert.throws(
+  RangeError,
+  () => Temporal.ZonedDateTime.from(properties, { offset: "reject" }),
+  "no fuzzy matching is done on offset in property bag (offset=reject)"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/argument-propertybag-timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/argument-propertybag-timezone-string-datetime.js
new file mode 100644
index 0000000000..c88ed0455e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/argument-propertybag-timezone-string-datetime.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.equals
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+const expectedTimeZone = "America/Vancouver";
+const instance = new Temporal.ZonedDateTime(0n, expectedTimeZone);
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+assert(instance.equals({ year: 1969, month: 12, day: 31, hour: 16, timeZone }), "date-time + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+assert(instance.equals({ year: 1969, month: 12, day: 31, hour: 16, timeZone }), "date-time + Z + IANA annotation is the IANA time zone");
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+assert(instance.equals({ year: 1969, month: 12, day: 31, hour: 16, timeZone }), "date-time + offset + IANA annotation is the IANA time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/canonicalize-iana-identifiers-before-comparing.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/canonicalize-iana-identifiers-before-comparing.js
new file mode 100644
index 0000000000..1139d39f4e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/canonicalize-iana-identifiers-before-comparing.js
@@ -0,0 +1,21 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.equals
+description: ZonedDateTime.p.equals canonicalizes time zone IDs before comparing them
+features: [Temporal]
+---*/
+
+const calcutta = Temporal.ZonedDateTime.from('2020-01-01T00:00:00+05:30[Asia/Calcutta]');
+const kolkata = Temporal.ZonedDateTime.from('2020-01-01T00:00:00+05:30[Asia/Kolkata]');
+const colombo = Temporal.ZonedDateTime.from('2020-01-01T00:00:00+05:30[Asia/Colombo]');
+
+assert.sameValue(calcutta.equals(kolkata), true);
+assert.sameValue(calcutta.equals(kolkata.toString()), true);
+assert.sameValue(kolkata.equals(calcutta), true);
+assert.sameValue(kolkata.equals(calcutta.toString()), true);
+assert.sameValue(calcutta.equals(colombo), false);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/custom-time-zone-ids-case-sensitive.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/custom-time-zone-ids-case-sensitive.js
new file mode 100644
index 0000000000..1a1fe83615
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/custom-time-zone-ids-case-sensitive.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.equals
+description: Custom time zone IDs are compared case-sensitively
+features: [Temporal]
+---*/
+
+class Custom extends Temporal.TimeZone {
+  constructor(id) {
+    super("UTC");
+    this._id = id;
+  }
+  get id() {
+    return this._id;
+  }
+}
+const custom = Temporal.ZonedDateTime.from({ year: 2020, month: 1, day: 1, timeZone: new Custom("Moon/Cheese") });
+const customSameCase = custom.withTimeZone(new Custom("Moon/Cheese"));
+const customDifferentCase = custom.withTimeZone(new Custom("MOON/CHEESE"));
+
+assert.sameValue(custom.equals(customSameCase), true);
+assert.sameValue(custom.equals(customDifferentCase), false);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..0a8b2aca0e
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.zoneddatetime.prototype.equals
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "gregory");
+const base = { era: "ad", month: 5, day: 2, hour: 15, timeZone: "UTC", calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.equals({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.equals({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/sub-minute-offset.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/sub-minute-offset.js
new file mode 100644
index 0000000000..da6aef1883
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/equals/sub-minute-offset.js
@@ -0,0 +1,38 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.equals
+description: Fuzzy matching behaviour for UTC offset in ISO 8601 string with named time zones
+features: [Temporal]
+---*/
+
+const expectedNanoseconds = BigInt((44 * 60 + 30) * 1e9);
+const timeZone = new Temporal.TimeZone("Africa/Monrovia");
+const instance = new Temporal.ZonedDateTime(expectedNanoseconds, timeZone);
+
+let result = instance.equals("1970-01-01T00:00:00-00:45[Africa/Monrovia]");
+assert.sameValue(result, true, "UTC offset rounded to minutes is accepted");
+
+result = instance.equals("1970-01-01T00:00:00-00:44:30[Africa/Monrovia]");
+assert.sameValue(result, true, "Unrounded sub-minute UTC offset also accepted");
+
+assert.throws(
+  RangeError,
+  () => instance.equals("1970-01-01T00:00:00-00:44:30[-00:45]"),
+  "minute rounding not supported for offset time zones"
+);
+
+const properties = {
+  offset: "-00:45",
+  year: 1970,
+  month: 1,
+  day: 1,
+  minute: 44,
+  second: 30,
+  timeZone
+};
+assert.throws(RangeError, () => instance.equals(properties), "no fuzzy matching is done on offset in property bag");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/branding.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/branding.js
new file mode 100644
index 0000000000..84f10f82b9
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/branding.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.era
+description: Throw a TypeError if the receiver is invalid
+features: [Symbol, Temporal]
+---*/
+
+const era = Object.getOwnPropertyDescriptor(Temporal.ZonedDateTime.prototype, "era").get;
+
+assert.sameValue(typeof era, "function");
+
+assert.throws(TypeError, () => era.call(undefined), "undefined");
+assert.throws(TypeError, () => era.call(null), "null");
+assert.throws(TypeError, () => era.call(true), "true");
+assert.throws(TypeError, () => era.call(""), "empty string");
+assert.throws(TypeError, () => era.call(Symbol()), "symbol");
+assert.throws(TypeError, () => era.call(1), "1");
+assert.throws(TypeError, () => era.call({}), "plain object");
+assert.throws(TypeError, () => era.call(Temporal.ZonedDateTime), "Temporal.ZonedDateTime");
+assert.throws(TypeError, () => era.call(Temporal.ZonedDateTime.prototype), "Temporal.ZonedDateTime.prototype");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/prop-desc.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/prop-desc.js
new file mode 100644
index 0000000000..d247224b40
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/prop-desc.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.era
+description: The "era" property of Temporal.ZonedDateTime.prototype
+features: [Temporal]
+---*/
+
+const descriptor = Object.getOwnPropertyDescriptor(Temporal.ZonedDateTime.prototype, "era");
+assert.sameValue(typeof descriptor.get, "function");
+assert.sameValue(descriptor.set, undefined);
+assert.sameValue(descriptor.enumerable, false);
+assert.sameValue(descriptor.configurable, true);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-non-integer.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-non-integer.js
new file mode 100644
index 0000000000..222be0b287
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-non-integer.js
@@ -0,0 +1,18 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.era
+description: RangeError thrown if time zone reports an offset that is not an integer number of nanoseconds
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[3600_000_000_000.5, NaN, -Infinity, Infinity].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(RangeError, () => datetime.era);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-not-callable.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-not-callable.js
new file mode 100644
index 0000000000..47c31fdd68
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-not-callable.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.era
+description: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable
+features: [BigInt, Symbol, Temporal, arrow-function]
+---*/
+
+[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach((notCallable) => {
+  const timeZone = new Temporal.TimeZone("UTC");
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  timeZone.getOffsetNanosecondsFor = notCallable;
+  assert.throws(
+    TypeError,
+    () => datetime.era,
+    `Uncallable ${notCallable === null ? 'null' : typeof notCallable} getOffsetNanosecondsFor should throw TypeError`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-out-of-range.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-out-of-range.js
new file mode 100644
index 0000000000..2544695b31
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-out-of-range.js
@@ -0,0 +1,18 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.era
+description: RangeError thrown if time zone reports an offset that is out of range
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[-86400_000_000_000, 86400_000_000_000].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(RangeError, () => datetime.era);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-wrong-type.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-wrong-type.js
new file mode 100644
index 0000000000..300233e3d6
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/timezone-getoffsetnanosecondsfor-wrong-type.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.era
+description: TypeError thrown if time zone reports an offset that is not a Number
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[
+  undefined,
+  null,
+  true,
+  "+01:00",
+  Symbol(),
+  3600_000_000_000n,
+  {},
+  { valueOf() { return 3600_000_000_000; } },
+].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(TypeError, () => datetime.era);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/validate-calendar-value.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/validate-calendar-value.js
new file mode 100644
index 0000000000..13f0bc5e8c
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/era/validate-calendar-value.js
@@ -0,0 +1,54 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.era
+description: Validate result returned from calendar era() method
+features: [Temporal]
+---*/
+
+const badResults = [
+  [null, TypeError],
+  [false, TypeError],
+  [Infinity, TypeError],
+  [-Infinity, TypeError],
+  [NaN, TypeError],
+  [-7, TypeError],
+  [-0.1, TypeError],
+  [Symbol("foo"), TypeError],
+  [7n, TypeError],
+  [{}, TypeError],
+  [true, TypeError],
+  [7.1, TypeError],
+  [{valueOf() { return "7"; }}, TypeError],
+];
+
+badResults.forEach(([result, error]) => {
+  const calendar = new class extends Temporal.Calendar {
+    era() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+  assert.throws(error, () => instance.era, `${typeof result} ${String(result)} not converted to string`);
+});
+
+const preservedResults = [
+  undefined,
+  "string",
+  "7",
+  "7.5",
+];
+
+preservedResults.forEach(result => {
+  const calendar = new class extends Temporal.Calendar {
+    era() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+  assert.sameValue(instance.era, result, `${typeof result} ${String(result)} preserved`);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/branding.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/branding.js
new file mode 100644
index 0000000000..483656efd9
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/branding.js
@@ -0,0 +1,25 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.erayear
+description: Throw a TypeError if the receiver is invalid
+features: [Symbol, Temporal]
+---*/
+
+const eraYear = Object.getOwnPropertyDescriptor(Temporal.ZonedDateTime.prototype, "eraYear").get;
+
+assert.sameValue(typeof eraYear, "function");
+
+assert.throws(TypeError, () => eraYear.call(undefined), "undefined");
+assert.throws(TypeError, () => eraYear.call(null), "null");
+assert.throws(TypeError, () => eraYear.call(true), "true");
+assert.throws(TypeError, () => eraYear.call(""), "empty string");
+assert.throws(TypeError, () => eraYear.call(Symbol()), "symbol");
+assert.throws(TypeError, () => eraYear.call(1), "1");
+assert.throws(TypeError, () => eraYear.call({}), "plain object");
+assert.throws(TypeError, () => eraYear.call(Temporal.ZonedDateTime), "Temporal.ZonedDateTime");
+assert.throws(TypeError, () => eraYear.call(Temporal.ZonedDateTime.prototype), "Temporal.ZonedDateTime.prototype");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/prop-desc.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/prop-desc.js
new file mode 100644
index 0000000000..92f5485722
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/prop-desc.js
@@ -0,0 +1,17 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.erayear
+description: The "eraYear" property of Temporal.ZonedDateTime.prototype
+features: [Temporal]
+---*/
+
+const descriptor = Object.getOwnPropertyDescriptor(Temporal.ZonedDateTime.prototype, "eraYear");
+assert.sameValue(typeof descriptor.get, "function");
+assert.sameValue(descriptor.set, undefined);
+assert.sameValue(descriptor.enumerable, false);
+assert.sameValue(descriptor.configurable, true);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-non-integer.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-non-integer.js
new file mode 100644
index 0000000000..ca170de242
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-non-integer.js
@@ -0,0 +1,18 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.erayear
+description: RangeError thrown if time zone reports an offset that is not an integer number of nanoseconds
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[3600_000_000_000.5, NaN, -Infinity, Infinity].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(RangeError, () => datetime.eraYear);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-not-callable.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-not-callable.js
new file mode 100644
index 0000000000..6631a41232
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-not-callable.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.erayear
+description: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable
+features: [BigInt, Symbol, Temporal, arrow-function]
+---*/
+
+[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach((notCallable) => {
+  const timeZone = new Temporal.TimeZone("UTC");
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  timeZone.getOffsetNanosecondsFor = notCallable;
+  assert.throws(
+    TypeError,
+    () => datetime.eraYear,
+    `Uncallable ${notCallable === null ? 'null' : typeof notCallable} getOffsetNanosecondsFor should throw TypeError`
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-out-of-range.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-out-of-range.js
new file mode 100644
index 0000000000..00a6903d20
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-out-of-range.js
@@ -0,0 +1,18 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.erayear
+description: RangeError thrown if time zone reports an offset that is out of range
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[-86400_000_000_000, 86400_000_000_000].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(RangeError, () => datetime.eraYear);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-wrong-type.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-wrong-type.js
new file mode 100644
index 0000000000..c743b5d188
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/timezone-getoffsetnanosecondsfor-wrong-type.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.erayear
+description: TypeError thrown if time zone reports an offset that is not a Number
+features: [Temporal]
+includes: [temporalHelpers.js]
+---*/
+
+[
+  undefined,
+  null,
+  true,
+  "+01:00",
+  Symbol(),
+  3600_000_000_000n,
+  {},
+  { valueOf() { return 3600_000_000_000; } },
+].forEach((wrongOffset) => {
+  const timeZone = TemporalHelpers.specificOffsetTimeZone(wrongOffset);
+  const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, timeZone);
+  assert.throws(TypeError, () => datetime.eraYear);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/validate-calendar-value.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/validate-calendar-value.js
new file mode 100644
index 0000000000..6b83d83c73
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/eraYear/validate-calendar-value.js
@@ -0,0 +1,54 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-get-temporal.zoneddatetime.prototype.erayear
+description: Validate result returned from calendar eraYear() method
+features: [Temporal]
+---*/
+
+const badResults = [
+  [null, TypeError],
+  [false, TypeError],
+  [Infinity, RangeError],
+  [-Infinity, RangeError],
+  [NaN, RangeError],
+  [-0.1, RangeError],
+  ["string", TypeError],
+  [Symbol("foo"), TypeError],
+  [7n, TypeError],
+  [{}, TypeError],
+  [true, TypeError],
+  [7.1, RangeError],
+  ["7", TypeError],
+  ["7.5", TypeError],
+  [{valueOf() { return 7; }}, TypeError],
+];
+
+badResults.forEach(([result, error]) => {
+  const calendar = new class extends Temporal.Calendar {
+    eraYear() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+  assert.throws(error, () => instance.eraYear, `${typeof result} ${String(result)} not converted to integer`);
+});
+
+const preservedResults = [
+  undefined,
+  -7,
+];
+
+preservedResults.forEach(result => {
+  const calendar = new class extends Temporal.Calendar {
+    eraYear() {
+      return result;
+    }
+  }("iso8601");
+  const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+  assert.sameValue(instance.eraYear, result, `${typeof result} ${String(result)} preserved`);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/argument-propertybag-timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/argument-propertybag-timezone-string-datetime.js
new file mode 100644
index 0000000000..b867e125fd
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/argument-propertybag-timezone-string-datetime.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.since
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+const expectedTimeZone = "America/Vancouver";
+const instance = new Temporal.ZonedDateTime(0n, expectedTimeZone);
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+instance.since({ year: 2020, month: 5, day: 2, timeZone });
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+instance.since({ year: 2020, month: 5, day: 2, timeZone });
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+instance.since({ year: 2020, month: 5, day: 2, timeZone });
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/canonicalize-iana-identifiers-before-comparing.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/canonicalize-iana-identifiers-before-comparing.js
new file mode 100644
index 0000000000..3523b994d5
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/canonicalize-iana-identifiers-before-comparing.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.since
+description: Accept time zone identifiers that canonicalize to the same ID
+features: [Temporal]
+---*/
+
+const calcutta = Temporal.ZonedDateTime.from('2020-01-01T00:00:00+05:30[Asia/Calcutta]');
+const kolkata = Temporal.ZonedDateTime.from('2021-09-01T00:00:00+05:30[Asia/Kolkata]');
+const colombo = Temporal.ZonedDateTime.from('2022-08-01T00:00:00+05:30[Asia/Colombo]');
+
+// If the time zones resolve to the same canonical zone, then it shouldn't throw
+assert.sameValue(calcutta.since(kolkata, { largestUnit: 'day' }).toString(), '-P609D');
+assert.throws(RangeError, () => calcutta.since(colombo, { largestUnit: 'day' }));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/custom-time-zone-ids-case-sensitive.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/custom-time-zone-ids-case-sensitive.js
new file mode 100644
index 0000000000..a81fbb4f3a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/custom-time-zone-ids-case-sensitive.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.since
+description: Custom time zone IDs are compared case-sensitively
+features: [Temporal]
+---*/
+
+class Custom extends Temporal.TimeZone {
+  constructor(id) {
+    super("UTC");
+    this._id = id;
+  }
+  get id() {
+    return this._id;
+  }
+}
+const custom = Temporal.ZonedDateTime.from({ year: 2020, month: 1, day: 1, timeZone: new Custom("Moon/Cheese") });
+const customSameCase = custom.withTimeZone(new Custom("Moon/Cheese")).with({ year: 2021 });
+const customDifferentCase = custom.withTimeZone(new Custom("MOON/CHEESE")).with({ year: 2021 });
+
+assert.sameValue(custom.since(customSameCase, { largestUnit: "year" }).toString(), "-P1Y");
+assert.throws(RangeError, () => custom.since(customDifferentCase, { largestUnit: "year" }));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..3f0fc2d65f
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.zoneddatetime.prototype.since
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "gregory");
+const base = { era: "ad", month: 5, day: 2, hour: 15, timeZone: "UTC", calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.since({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.since({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/sub-minute-offset.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/sub-minute-offset.js
new file mode 100644
index 0000000000..cc5d25cbcb
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/since/sub-minute-offset.js
@@ -0,0 +1,51 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.since
+description: Fuzzy matching behaviour for UTC offset in ISO 8601 string with named time zones
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const timeZone = new Temporal.TimeZone("Africa/Monrovia");
+const instance = new Temporal.ZonedDateTime(0n, timeZone);
+
+let result = instance.since("1970-01-01T00:44:30-00:44:30[Africa/Monrovia]");
+TemporalHelpers.assertDuration(result, 0, 0, 0, 0, -1, -29, 0, 0, 0, 0, "UTC offset rounded to minutes is accepted");
+
+result = instance.since("1970-01-01T00:44:30-00:44:30[Africa/Monrovia]");
+TemporalHelpers.assertDuration(
+  result,
+  0,
+  0,
+  0,
+  0,
+  -1,
+  -29,
+  0,
+  0,
+  0,
+  0,
+  "Unrounded sub-minute UTC offset also accepted"
+);
+
+assert.throws(
+  RangeError,
+  () => instance.since("1970-01-01T00:44:30+00:44:30[+00:45"),
+  "minute rounding not supported for offset time zones"
+);
+
+const properties = {
+  offset: "-00:45",
+  year: 1970,
+  month: 1,
+  day: 1,
+  minute: 44,
+  second: 30,
+  timeZone
+};
+assert.throws(RangeError, () => instance.since(properties), "no fuzzy matching is done on offset in property bag");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/calendar-mismatch.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/calendar-mismatch.js
new file mode 100644
index 0000000000..c34862ddf7
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/calendar-mismatch.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.tolocalestring
+description: Calendar must match the locale calendar if not "iso8601"
+features: [Temporal, Intl-enumeration]
+---*/
+
+const localeCalendar = new Intl.DateTimeFormat().resolvedOptions().calendar;
+assert.notSameValue(localeCalendar, "iso8601", "no locale has the ISO calendar");
+
+const sameCalendarInstance = new Temporal.ZonedDateTime(0n, "UTC", localeCalendar);
+const result = sameCalendarInstance.toLocaleString();
+assert.sameValue(typeof result, "string", "toLocaleString() succeeds when instance has the same calendar as locale");
+
+const isoInstance = new Temporal.ZonedDateTime(0n, "UTC", "iso8601");
+assert.sameValue(isoInstance.toLocaleString(), result, "toLocaleString() succeeds when instance has the ISO calendar")
+
+// Pick a different calendar that is not ISO and not the locale's calendar
+const calendars = new Set(Intl.supportedValuesOf("calendar"));
+calendars.delete("iso8601");
+calendars.delete(localeCalendar);
+const differentCalendar = calendars.values().next().value;
+
+const differentCalendarInstance = new Temporal.ZonedDateTime(0n, "UTC", differentCalendar);
+assert.throws(RangeError, () => differentCalendarInstance.toLocaleString(), "calendar mismatch");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/custom-time-zone-name-not-supported.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/custom-time-zone-name-not-supported.js
new file mode 100644
index 0000000000..1e1a0f17b7
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/custom-time-zone-name-not-supported.js
@@ -0,0 +1,20 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.tolocalestring
+description: >
+  Custom time zones with unofficial names are not supported for locale formatting
+features: [Temporal]
+---*/
+
+const timeZone = {
+  id: "Etc/Custom_Zone",
+  getPossibleInstantsFor() {},
+  getOffsetNanosecondsFor() {},
+};
+const datetime = new Temporal.ZonedDateTime(0n, timeZone);
+assert.throws(RangeError, () => datetime.toLocaleString(), "Custom time zones with non-IANA identifiers not supported in Intl");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/locales-undefined.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/locales-undefined.js
new file mode 100644
index 0000000000..8f4f19308a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/locales-undefined.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.tolocalestring
+description: Omitting the locales argument defaults to the DateTimeFormat default
+features: [BigInt, Temporal]
+---*/
+
+const datetime = new Temporal.ZonedDateTime(957270896_987_650_000n, "UTC");
+const defaultFormatter = new Intl.DateTimeFormat([], {
+  year: "numeric",
+  month: "numeric",
+  day: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  timeZoneName: "short",
+  timeZone: "UTC",
+});
+const expected = defaultFormatter.format(datetime.toInstant());
+
+const actualExplicit = datetime.toLocaleString(undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = datetime.toLocaleString();
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/offset-time-zone-not-supported.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/offset-time-zone-not-supported.js
new file mode 100644
index 0000000000..4522df5ab2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/offset-time-zone-not-supported.js
@@ -0,0 +1,14 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.tolocalestring
+description: Offset time zones are not supported yet by Intl
+features: [Temporal]
+---*/
+
+const datetime = new Temporal.ZonedDateTime(0n, "+00:00");
+assert.throws(RangeError, () => datetime.toLocaleString(), "Intl.DateTimeFormat does not yet specify what to do with offset time zones");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-conflict.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-conflict.js
new file mode 100644
index 0000000000..385b3f9f05
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-conflict.js
@@ -0,0 +1,51 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Kate Miháliková. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sup-temporal.zoneddatetime.prototype.tolocalestring
+description: >
+    Conflicting properties of dateStyle must be rejected with a TypeError for the options argument
+info: |
+    Using sec-temporal-getdatetimeformatpattern:
+    GetDateTimeFormatPattern ( dateStyle, timeStyle, matcher, opt, dataLocaleData, hc )
+
+    1. If dateStyle is not undefined or timeStyle is not undefined, then
+      a. For each row in Table 7, except the header row, do
+        i. Let prop be the name given in the Property column of the row.
+        ii. Let p be opt.[[<prop>]].
+        iii. If p is not undefined, then
+          1. Throw a TypeError exception.
+features: [BigInt, Temporal]
+---*/
+
+// Table 14 - Supported fields + example value for each field
+const conflictingOptions = [
+  [ "weekday", "short" ],
+  [ "era", "short" ],
+  [ "year", "numeric" ],
+  [ "month", "numeric" ],
+  [ "day", "numeric" ],
+  [ "hour", "numeric" ],
+  [ "minute", "numeric" ],
+  [ "second", "numeric" ],
+  [ "dayPeriod", "short" ],
+  [ "fractionalSecondDigits", 3 ],
+  [ "timeZoneName", "short" ],
+];
+const datetime = new Temporal.ZonedDateTime(957270896_987_650_000n, "UTC");
+
+assert.sameValue(typeof datetime.toLocaleString("en", { dateStyle: "short" }), "string");
+assert.sameValue(typeof datetime.toLocaleString("en", { timeStyle: "short" }), "string");
+
+for (const [ option, value ] of conflictingOptions) {
+  assert.throws(TypeError, function() {
+    datetime.toLocaleString("en", { [option]: value, dateStyle: "short" });
+  }, `datetime.toLocaleString("en", { ${option}: "${value}",  dateStyle: "short" }) throws TypeError`);
+
+  assert.throws(TypeError, function() {
+    datetime.toLocaleString("en", { [option]: value, timeStyle: "short" });
+  }, `datetime.toLocaleString("en", { ${option}: "${value}",  timeStyle: "short" }) throws TypeError`);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-timeZone.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-timeZone.js
new file mode 100644
index 0000000000..034c485084
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-timeZone.js
@@ -0,0 +1,18 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.tolocalestring
+description: >
+  Options must not have a timeZone property, even if it agrees with the
+  instance's time zone
+features: [Temporal]
+---*/
+
+const datetime = new Temporal.ZonedDateTime(0n, "UTC");
+
+assert.throws(TypeError, () => datetime.toLocaleString("en-US", { timeZone: "Europe/Vienna" }), "timeZone option disallowed");
+assert.throws(TypeError, () => datetime.toLocaleString("en-US", { timeZone: "UTC" }), "timeZone option disallowed even if it agrees with instance's time zone");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-timeZoneName-affects-instance-time-zone.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-timeZoneName-affects-instance-time-zone.js
new file mode 100644
index 0000000000..51a5c1daef
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-timeZoneName-affects-instance-time-zone.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.tolocalestring
+description: timeZoneName option affects formatting of the instance's time zone
+locale: [en-US]
+features: [Temporal]
+---*/
+
+const datetime = new Temporal.ZonedDateTime(0n, "Europe/Vienna");
+
+const resultShort = datetime.toLocaleString("en-US", { timeZoneName: "short" });
+const resultLong = datetime.toLocaleString("en-US", { timeZoneName: "long" });
+assert.notSameValue(resultShort, resultLong, "formats with different timeZoneName options should be different");
+assert(resultLong.includes("Central European Standard Time"), "time zone name can be written out in full");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-undefined.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-undefined.js
new file mode 100644
index 0000000000..a1286949a9
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/options-undefined.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.tolocalestring
+description: Verify that undefined options are handled correctly.
+features: [BigInt, Temporal]
+---*/
+
+const datetime = new Temporal.ZonedDateTime(957270896_987_650_000n, "UTC");
+const defaultFormatter = new Intl.DateTimeFormat('en', {
+  year: "numeric",
+  month: "numeric",
+  day: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  timeZoneName: "short",
+  timeZone: "UTC",
+});
+const expected = defaultFormatter.format(datetime.toInstant());
+
+const actualExplicit = datetime.toLocaleString('en', undefined);
+assert.sameValue(actualExplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+const actualImplicit = datetime.toLocaleString('en');
+assert.sameValue(actualImplicit, expected, "default locale is determined by Intl.DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/time-zone-canonicalized.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/time-zone-canonicalized.js
new file mode 100644
index 0000000000..a2c010e248
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/toLocaleString/time-zone-canonicalized.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.tolocalestring
+description: Custom time zone names are canonicalized
+features: [Temporal]
+---*/
+
+const timeZone1 = {
+  id: "Asia/Kolkata",
+  getPossibleInstantsFor() {},
+  getOffsetNanosecondsFor() {},
+};
+const datetime1 = new Temporal.ZonedDateTime(0n, timeZone1);
+
+const timeZone2 = {
+  id: "Asia/Calcutta",
+  getPossibleInstantsFor() {},
+  getOffsetNanosecondsFor() {},
+};
+const datetime2 = new Temporal.ZonedDateTime(0n, timeZone2);
+
+assert.sameValue(datetime1.toLocaleString(), datetime2.toLocaleString(), "Time zone names are canonicalized before passing to DateTimeFormat");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/argument-propertybag-timezone-string-datetime.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/argument-propertybag-timezone-string-datetime.js
new file mode 100644
index 0000000000..c491b7592b
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/argument-propertybag-timezone-string-datetime.js
@@ -0,0 +1,22 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.until
+description: Conversion of ISO date-time strings to Temporal.TimeZone instances (with IANA time zones)
+features: [Temporal]
+---*/
+
+const expectedTimeZone = "America/Vancouver";
+const instance = new Temporal.ZonedDateTime(0n, expectedTimeZone);
+let timeZone = "2021-08-19T17:30[America/Vancouver]";
+instance.until({ year: 2020, month: 5, day: 2, timeZone });
+
+timeZone = "2021-08-19T17:30Z[America/Vancouver]";
+instance.until({ year: 2020, month: 5, day: 2, timeZone });
+
+timeZone = "2021-08-19T17:30-07:00[America/Vancouver]";
+instance.until({ year: 2020, month: 5, day: 2, timeZone });
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/canonicalize-iana-identifiers-before-comparing.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/canonicalize-iana-identifiers-before-comparing.js
new file mode 100644
index 0000000000..eb93477e30
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/canonicalize-iana-identifiers-before-comparing.js
@@ -0,0 +1,19 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.until
+description: Accept time zone identifiers that canonicalize to the same ID
+features: [Temporal]
+---*/
+
+const calcutta = Temporal.ZonedDateTime.from('2020-01-01T00:00:00+05:30[Asia/Calcutta]');
+const kolkata = Temporal.ZonedDateTime.from('2021-09-01T00:00:00+05:30[Asia/Kolkata]');
+const colombo = Temporal.ZonedDateTime.from('2022-08-01T00:00:00+05:30[Asia/Colombo]');
+
+// If the time zones resolve to the same canonical zone, then it shouldn't throw
+assert.sameValue(calcutta.until(kolkata, { largestUnit: 'day' }).toString(), 'P609D');
+assert.throws(RangeError, () => calcutta.until(colombo, { largestUnit: 'day' }));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/custom-time-zone-ids-case-sensitive.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/custom-time-zone-ids-case-sensitive.js
new file mode 100644
index 0000000000..7c1ad5b356
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/custom-time-zone-ids-case-sensitive.js
@@ -0,0 +1,27 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.since
+description: Custom time zone IDs are compared case-sensitively
+features: [Temporal]
+---*/
+
+class Custom extends Temporal.TimeZone {
+  constructor(id) {
+    super("UTC");
+    this._id = id;
+  }
+  get id() {
+    return this._id;
+  }
+}
+const custom = Temporal.ZonedDateTime.from({ year: 2020, month: 1, day: 1, timeZone: new Custom("Moon/Cheese") });
+const customSameCase = custom.withTimeZone(new Custom("Moon/Cheese")).with({ year: 2021 });
+const customDifferentCase = custom.withTimeZone(new Custom("MOON/CHEESE")).with({ year: 2021 });
+
+assert.sameValue(custom.until(customSameCase, { largestUnit: "year" }).toString(), "P1Y");
+assert.throws(RangeError, () => custom.until(customDifferentCase, { largestUnit: "year" }));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..2d9745b47a
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.zoneddatetime.prototype.until
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "gregory");
+const base = { era: "ad", month: 5, day: 2, hour: 15, timeZone: "UTC", calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.until({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.until({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/sub-minute-offset.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/sub-minute-offset.js
new file mode 100644
index 0000000000..b8fc742f2c
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/until/sub-minute-offset.js
@@ -0,0 +1,38 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.until
+description: Fuzzy matching behaviour for UTC offset in ISO 8601 string with named time zones
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const timeZone = new Temporal.TimeZone("Africa/Monrovia");
+const instance = new Temporal.ZonedDateTime(0n, timeZone);
+
+let result = instance.until("1970-01-01T00:44:30-00:44:30[Africa/Monrovia]");
+TemporalHelpers.assertDuration(result, 0, 0, 0, 0, 1, 29, 0, 0, 0, 0, "UTC offset rounded to minutes is accepted");
+
+result = instance.until("1970-01-01T00:44:30-00:44:30[Africa/Monrovia]");
+TemporalHelpers.assertDuration(result, 0, 0, 0, 0, 1, 29, 0, 0, 0, 0, "Unrounded sub-minute UTC offset also accepted");
+
+assert.throws(
+  RangeError,
+  () => instance.until("1970-01-01T00:44:30+00:44:30[+00:45"),
+  "minute rounding not supported for offset time zones"
+);
+
+const properties = {
+  offset: "-00:45",
+  year: 1970,
+  month: 1,
+  day: 1,
+  minute: 44,
+  second: 30,
+  timeZone
+};
+assert.throws(RangeError, () => instance.until(properties), "no fuzzy matching is done on offset in property bag");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/with/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/with/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/with/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/with/offset-property-sub-minute.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/with/offset-property-sub-minute.js
new file mode 100644
index 0000000000..5825173877
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/with/offset-property-sub-minute.js
@@ -0,0 +1,57 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.with
+description: Fuzzy matching behaviour with UTC offsets in ISO 8601 strings with named time zones and offset option
+includes: [temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const timeZone = new Temporal.TimeZone("Africa/Monrovia");
+const instance = Temporal.ZonedDateTime.from({ year: 1970, month: 1, day: 1, hour: 12, timeZone });
+assert.sameValue(instance.offset, "-00:44:30", "original offset");
+const properties = { day: 2, offset: "-00:45" };
+
+["ignore", "prefer"].forEach((offset) => {
+  const result = instance.with(properties, { offset });
+  assert.sameValue(result.epochNanoseconds, 132270_000_000_000n, `ignores new offset (offset=${offset})`);
+  assert.sameValue(result.offset, instance.offset, "offset property is unchanged");
+  TemporalHelpers.assertPlainDateTime(
+    result.toPlainDateTime(),
+    1970,
+    1,
+    "M01",
+    2,
+    12,
+    0,
+    0,
+    0,
+    0,
+    0,
+    "wall time is not shifted"
+  );
+});
+
+const result = instance.with(properties, { offset: "use" });
+assert.sameValue(result.epochNanoseconds, 132300_000_000_000n, "accepts HH:MM rounded offset (offset=use)");
+assert.sameValue(result.offset, instance.offset, "offset property is unchanged");
+TemporalHelpers.assertPlainDateTime(
+  result.toPlainDateTime(),
+  1970,
+  1,
+  "M01",
+  2,
+  12,
+  0,
+  30,
+  0,
+  0,
+  0,
+  "wall time is shifted by the difference between exact and rounded offset"
+);
+
+assert.throws(RangeError, () => instance.with(properties, { offset: "reject" }), "no fuzzy matching is done in with()");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/with/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/with/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/with/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withCalendar/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withCalendar/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withCalendar/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withCalendar/calendar-case-insensitive.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withCalendar/calendar-case-insensitive.js
new file mode 100644
index 0000000000..4eaf9f7f82
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withCalendar/calendar-case-insensitive.js
@@ -0,0 +1,39 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.withcalendar
+description: Calendar names are case-insensitive
+features: [Temporal]
+---*/
+
+const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", {
+  dateAdd() {},
+  dateFromFields() {},
+  dateUntil() {},
+  day() {},
+  dayOfWeek() {},
+  dayOfYear() {},
+  daysInMonth() {},
+  daysInWeek() {},
+  daysInYear() {},
+  fields() {},
+  id: "replace-me",
+  inLeapYear() {},
+  mergeFields() {},
+  month() {},
+  monthCode() {},
+  monthDayFromFields() {},
+  monthsInYear() {},
+  weekOfYear() {},
+  year() {},
+  yearMonthFromFields() {},
+  yearOfWeek() {},
+});
+
+const arg = "jApAnEsE";;
+const result = instance.withCalendar(arg);
+assert.sameValue(result.calendarId, "japanese", "Calendar is case-insensitive");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withCalendar/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withCalendar/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withCalendar/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withPlainDate/browser.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withPlainDate/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withPlainDate/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withPlainDate/infinity-throws-rangeerror.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withPlainDate/infinity-throws-rangeerror.js
new file mode 100644
index 0000000000..fce8492195
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withPlainDate/infinity-throws-rangeerror.js
@@ -0,0 +1,24 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Throws if eraYear in the property bag is Infinity or -Infinity
+esid: sec-temporal.zoneddatetime.prototype.withplaindate
+includes: [compareArray.js, temporalHelpers.js]
+features: [Temporal]
+---*/
+
+const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "gregory");
+const base = { era: "ad", month: 5, day: 2, calendar: "gregory" };
+
+[Infinity, -Infinity].forEach((inf) => {
+  assert.throws(RangeError, () => instance.withPlainDate({ ...base, eraYear: inf }), `eraYear property cannot be ${inf}`);
+
+  const calls = [];
+  const obj = TemporalHelpers.toPrimitiveObserver(calls, inf, "eraYear");
+  assert.throws(RangeError, () => instance.withPlainDate({ ...base, eraYear: obj }));
+  assert.compareArray(calls, ["get eraYear.valueOf", "call eraYear.valueOf"], "it fails after fetching the primitive value");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withPlainDate/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withPlainDate/shell.js
new file mode 100644
index 0000000000..60f74c2518
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/prototype/withPlainDate/shell.js
@@ -0,0 +1,2158 @@
+// GENERATED, DO NOT EDIT
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/intl402/Temporal/ZonedDateTime/shell.js b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/ZonedDateTime/shell.js
diff --git a/js/src/tests/test262/intl402/Temporal/browser.js b/js/src/tests/test262/intl402/Temporal/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/browser.js
diff --git a/js/src/tests/test262/intl402/Temporal/shell.js b/js/src/tests/test262/intl402/Temporal/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/intl402/Temporal/shell.js