Temporal: Tests for PlainDateTime exposed in DisambiguatePossibleInstants

In the AO DisambiguatePossibleInstants, a PlainDateTime instance is passed
to user code. This instance should have the built-in ISO 8601 calendar.
Here are some tests that ensure it does.

See tc39/proposal-temporal#2671.

test/built-ins/Temporal/Duration/compare/relativeto-propertybag-getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,55 @@
+// 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.duration.prototype.compare
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+const relativeTo = { year: 2000, month: 5, day: 2, timeZone, calendar: nonBuiltinISOCalendar };
+
+Temporal.Duration.compare(new Temporal.Duration(1), new Temporal.Duration(2), { relativeTo });
+
+assert.sameValue(timeZone.calls, 6, "getPossibleInstantsFor should have been called 6 times");

test/built-ins/Temporal/Duration/prototype/add/relativeto-propertybag-getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,56 @@
+// 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.duration.prototype.add
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+const relativeTo = { year: 2000, month: 5, day: 2, timeZone, calendar: nonBuiltinISOCalendar };
+
+const instance = new Temporal.Duration(1, 0, 0, 1);
+instance.add(new Temporal.Duration(0, 0, 0, 0, -24), { relativeTo });
+
+assert.sameValue(timeZone.calls, 6, "getPossibleInstantsFor should have been called 6 times");

test/built-ins/Temporal/Duration/prototype/round/relativeto-propertybag-getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,56 @@
+// 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.duration.prototype.round
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+const relativeTo = { year: 2000, month: 5, day: 2, timeZone, calendar: nonBuiltinISOCalendar };
+
+const instance = new Temporal.Duration(1, 0, 0, 0, 24);
+instance.round({ largestUnit: "years", relativeTo });
+
+assert.sameValue(timeZone.calls, 6, "getPossibleInstantsFor should have been called 6 times");

test/built-ins/Temporal/Duration/prototype/subtract/relativeto-propertybag-getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,56 @@
+// 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.duration.prototype.subtract
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+const relativeTo = { year: 2000, month: 5, day: 2, timeZone, calendar: nonBuiltinISOCalendar };
+
+const instance = new Temporal.Duration(1, 0, 0, 1);
+instance.subtract(new Temporal.Duration(0, 0, 0, 0, 24), { relativeTo });
+
+assert.sameValue(timeZone.calls, 6, "getPossibleInstantsFor should have been called 6 times");

test/built-ins/Temporal/Duration/prototype/total/relativeto-propertybag-getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,56 @@
+// 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.duration.prototype.total
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+const relativeTo = { year: 2000, month: 5, day: 2, timeZone, calendar: nonBuiltinISOCalendar };
+
+const instance = new Temporal.Duration(1, 0, 0, 0, 24);
+instance.total({ unit: "days", relativeTo });
+
+assert.sameValue(timeZone.calls, 10, "getPossibleInstantsFor should have been called 10 times");

test/built-ins/Temporal/PlainDate/prototype/toZonedDateTime/getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,55 @@
+// 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.tozoneddatetime
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+
+const instance = new Temporal.PlainDate(2000, 5, 2, nonBuiltinISOCalendar);
+instance.toZonedDateTime(timeZone);
+
+assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");

test/built-ins/Temporal/PlainDateTime/prototype/toZonedDateTime/getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,55 @@
+// 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.tozoneddatetime
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+
+const instance = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 0, 0, 0, nonBuiltinISOCalendar);
+instance.toZonedDateTime(timeZone);
+
+assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");

test/built-ins/Temporal/PlainTime/prototype/toZonedDateTime/getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,55 @@
+// 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.plaintime.prototype.tozoneddatetime
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+
+const instance = new Temporal.PlainTime(12, 34, 56);
+instance.toZonedDateTime({ timeZone, plainDate: new Temporal.PlainDate(2000, 5, 2, nonBuiltinISOCalendar) });
+
+assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");

test/built-ins/Temporal/TimeZone/prototype/getInstantFor/getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,56 @@
+// 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.timezone.prototype.getinstantfor
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+
+for (const disambiguation of ["earlier", "later", "compatible"]) {
+  const timeZone = new SkippedDateTime();
+  timeZone.getInstantFor(new Temporal.PlainDateTime(2000, 3, 4, 12, 34, 56, 0, 0, 0, nonBuiltinISOCalendar), { disambiguation });
+
+  assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");
+}

test/built-ins/Temporal/ZonedDateTime/compare/argument-propertybag-getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,58 @@
+// 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.compare
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone1 = new SkippedDateTime();
+const arg1 = { year: 2000, month: 5, day: 2, timeZone: timeZone1, calendar: nonBuiltinISOCalendar };
+const timeZone2 = new SkippedDateTime();
+const arg2 = { year: 2000, month: 5, day: 2, timeZone: timeZone2, calendar: nonBuiltinISOCalendar };
+
+Temporal.ZonedDateTime.compare(arg1, arg2);
+
+assert.sameValue(timeZone1.calls, 2, "getPossibleInstantsFor should have been called 2 times on first time zone");
+assert.sameValue(timeZone2.calls, 2, "getPossibleInstantsFor should have been called 2 times on second time zone");

test/built-ins/Temporal/ZonedDateTime/from/argument-propertybag-getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,55 @@
+// 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.from
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+const arg = { year: 2000, month: 5, day: 2, timeZone, calendar: nonBuiltinISOCalendar };
+
+Temporal.ZonedDateTime.from(arg);
+
+assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");

test/built-ins/Temporal/ZonedDateTime/prototype/equals/argument-propertybag-getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,56 @@
+// 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.equals
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+const arg = { year: 2000, month: 5, day: 2, timeZone, calendar: nonBuiltinISOCalendar };
+
+const instance = new Temporal.ZonedDateTime(0n, timeZone);
+instance.equals(arg);
+
+assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");

test/built-ins/Temporal/ZonedDateTime/prototype/hoursInDay/getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,55 @@
+// 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.hoursinday
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+
+const instance = new Temporal.ZonedDateTime(0n, timeZone, nonBuiltinISOCalendar);
+instance.hoursInDay;
+
+assert.sameValue(timeZone.calls, 4, "getPossibleInstantsFor should have been called 4 times");

test/built-ins/Temporal/ZonedDateTime/prototype/round/getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,55 @@
+// 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.round
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+
+const instance = new Temporal.ZonedDateTime(0n, timeZone, nonBuiltinISOCalendar);
+instance.round({ smallestUnit: "hours" });
+
+assert.sameValue(timeZone.calls, 6, "getPossibleInstantsFor should have been called 6 times");

test/built-ins/Temporal/ZonedDateTime/prototype/since/argument-propertybag-getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,56 @@
+// 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.since
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+const arg = { year: 2000, month: 5, day: 2, timeZone, calendar: nonBuiltinISOCalendar };
+
+const instance = new Temporal.ZonedDateTime(0n, timeZone);
+instance.since(arg);
+
+assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");

test/built-ins/Temporal/ZonedDateTime/prototype/startOfDay/getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,55 @@
+// 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.startofday
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+
+const instance = new Temporal.ZonedDateTime(0n, timeZone, nonBuiltinISOCalendar);
+instance.startOfDay();
+
+assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");

test/built-ins/Temporal/ZonedDateTime/prototype/until/argument-propertybag-getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,56 @@
+// 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.until
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+const arg = { year: 2000, month: 5, day: 2, timeZone, calendar: nonBuiltinISOCalendar };
+
+const instance = new Temporal.ZonedDateTime(0n, timeZone);
+instance.until(arg);
+
+assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");

test/built-ins/Temporal/ZonedDateTime/prototype/with/getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,58 @@
+// 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.with
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+
+for (const disambiguation of ["earlier", "later", "compatible"]) {
+  const timeZone = new SkippedDateTime();
+  const instance = new Temporal.ZonedDateTime(0n, timeZone, nonBuiltinISOCalendar);
+
+  instance.with({ day: 1 }, { disambiguation });
+
+  assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");
+}

test/built-ins/Temporal/ZonedDateTime/prototype/withPlainDate/getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,55 @@
+// 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.withplaindate
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+
+const instance = new Temporal.ZonedDateTime(0n, timeZone, nonBuiltinISOCalendar);
+instance.withPlainDate(new Temporal.PlainDate(2000, 5, 2, nonBuiltinISOCalendar));
+
+assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");

test/built-ins/Temporal/ZonedDateTime/prototype/withPlainTime/getpossibleinstantsfor-called-with-iso8601-calendar.js

@@ -0,0 +1,55 @@
+// 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.withplaintime
+description: >
+  Time zone's getPossibleInstantsFor is called with a PlainDateTime with the
+  built-in ISO 8601 calendar
+features: [Temporal]
+info: |
+  DisambiguatePossibleInstants:
+  2. Let _n_ be _possibleInstants_'s length.
+  ...
+  5. Assert: _n_ = 0.
+  ...
+  19. If _disambiguation_ is *"earlier"*, then
+    ...
+    c. Let _earlierDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+    d. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _earlierDateTime_).
+    ...
+  20. Assert: _disambiguation_ is *"compatible"* or *"later"*.
+  ...
+  23. Let _laterDateTime_ be ! CreateTemporalDateTime(..., *"iso8601"*).
+  24. Set _possibleInstants_ to ? GetPossibleInstantsFor(_timeZone_, _laterDateTime_).
+---*/
+
+class SkippedDateTime extends Temporal.TimeZone {
+  constructor() {
+    super("UTC");
+    this.calls = 0;
+  }
+
+  getPossibleInstantsFor(dateTime) {
+    // Calls occur in pairs. For the first one return no possible instants so
+    // that DisambiguatePossibleInstants will call it again
+    if (this.calls++ % 2 == 0) {
+      return [];
+    }
+
+    assert.sameValue(
+      dateTime.getISOFields().calendar,
+      "iso8601",
+      "getPossibleInstantsFor called with dateTime with built-in ISO 8601 calendar"
+    );
+    return super.getPossibleInstantsFor(dateTime);
+  }
+}
+
+const nonBuiltinISOCalendar = new Temporal.Calendar("iso8601");
+const timeZone = new SkippedDateTime();
+
+const instance = new Temporal.ZonedDateTime(0n, timeZone, nonBuiltinISOCalendar);
+instance.withPlainTime();
+
+assert.sameValue(timeZone.calls, 2, "getPossibleInstantsFor should have been called 2 times");