From 960070549bf611c7fecad001fa40b822671e2968 Mon Sep 17 00:00:00 2001 From: Philip Chimento Date: Fri, 17 Feb 2023 13:06:20 -0800 Subject: [PATCH] Store strings or objects in Temporal.ZonedDateTime [[TimeZone]] slot Normative PR: https://github.com/tc39/proposal-temporal/pull/2482 --- .../relativeto-propertybag-timezone-string.js | 21 ++++++++ .../relativeto-propertybag-timezone-string.js | 21 ++++++++ .../relativeto-propertybag-timezone-string.js | 21 ++++++++ .../relativeto-propertybag-timezone-string.js | 21 ++++++++ .../relativeto-propertybag-timezone-string.js | 21 ++++++++ ...ne-getoffsetnanosecondsfor-not-callable.js | 19 ------- .../prototype/toString/timezone-string.js | 21 ++++++++ .../toZonedDateTime/timezone-string.js | 21 ++++++++ .../toZonedDateTimeISO/timezone-string.js | 21 ++++++++ .../Temporal/Now/plainDate/timezone-string.js | 21 ++++++++ .../Now/plainDateISO/timezone-string.js | 21 ++++++++ .../Now/plainDateTime/timezone-string.js | 21 ++++++++ .../Now/plainDateTimeISO/timezone-string.js | 21 ++++++++ .../Now/plainTimeISO/timezone-string.js | 21 ++++++++ .../Now/zonedDateTime/timezone-string.js | 21 ++++++++ .../Now/zonedDateTimeISO/timezone-string.js | 21 ++++++++ .../toZonedDateTime/timezone-string.js | 21 ++++++++ .../toZonedDateTime/timezone-string.js | 21 ++++++++ .../toZonedDateTime/timezone-string.js | 21 ++++++++ .../Temporal/TimeZone/from/timezone-string.js | 21 ++++++++ .../argument-propertybag-timezone-string.js | 21 ++++++++ .../argument-propertybag-timezone-string.js | 21 ++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../argument-propertybag-timezone-string.js | 21 ++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../argument-propertybag-timezone-string.js | 21 ++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../argument-propertybag-timezone-string.js | 21 ++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../builtin-timezone-no-observable-calls.js | 34 ++++++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../prototype/withTimeZone/timezone-string.js | 21 ++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ .../builtin-timezone-no-observable-calls.js | 25 +++++++++ ...ne-getoffsetnanosecondsfor-not-callable.js | 49 ----------------- ...ne-getoffsetnanosecondsfor-not-callable.js | 54 ------------------- ...ne-getoffsetnanosecondsfor-not-callable.js | 54 ------------------- ...ne-getoffsetnanosecondsfor-not-callable.js | 49 ----------------- .../Now/zonedDateTime/calendar-string.js | 1 + .../zonedDateTime/calendar-timezone-string.js | 1 + .../Now/zonedDateTimeISO/timezone-string.js | 1 + ...ne-getoffsetnanosecondsfor-not-callable.js | 22 -------- ...ne-getoffsetnanosecondsfor-not-callable.js | 22 -------- ...ne-getoffsetnanosecondsfor-not-callable.js | 22 -------- ...ne-getoffsetnanosecondsfor-not-callable.js | 22 -------- ...ne-getoffsetnanosecondsfor-not-callable.js | 22 -------- 80 files changed, 1686 insertions(+), 335 deletions(-) delete mode 100644 test/built-ins/Temporal/Instant/prototype/toJSON/timezone-getoffsetnanosecondsfor-not-callable.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/add/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/day/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/dayOfWeek/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/dayOfYear/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/daysInMonth/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/daysInWeek/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/daysInYear/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/equals/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/getISOFields/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/hour/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/inLeapYear/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/microsecond/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/millisecond/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/minute/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/month/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/monthCode/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/monthsInYear/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/nanosecond/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/offset/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/offsetNanoseconds/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/round/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/second/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/since/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/startOfDay/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/subtract/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/timeZoneId/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/toJSON/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/toLocaleString/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/toPlainDate/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/toPlainDateTime/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/toPlainMonthDay/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/toPlainTime/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/toPlainYearMonth/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/toString/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/until/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/weekOfYear/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/with/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/withPlainDate/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/withPlainTime/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/withTimeZone/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/year/builtin-timezone-no-observable-calls.js create mode 100644 test/built-ins/Temporal/ZonedDateTime/prototype/yearOfWeek/builtin-timezone-no-observable-calls.js delete mode 100644 test/intl402/DateTimeFormat/prototype/format/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js delete mode 100644 test/intl402/DateTimeFormat/prototype/formatRange/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js delete mode 100644 test/intl402/DateTimeFormat/prototype/formatRangeToParts/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js delete mode 100644 test/intl402/DateTimeFormat/prototype/formatToParts/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js delete mode 100644 test/intl402/Temporal/PlainDate/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js delete mode 100644 test/intl402/Temporal/PlainDateTime/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js delete mode 100644 test/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js delete mode 100644 test/intl402/Temporal/PlainTime/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js delete mode 100644 test/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js diff --git a/test/built-ins/Temporal/Duration/compare/relativeto-propertybag-timezone-string.js b/test/built-ins/Temporal/Duration/compare/relativeto-propertybag-timezone-string.js index fe1aa0c8a3..40036b94a2 100644 --- a/test/built-ins/Temporal/Duration/compare/relativeto-propertybag-timezone-string.js +++ b/test/built-ins/Temporal/Duration/compare/relativeto-propertybag-timezone-string.js @@ -4,11 +4,32 @@ /*--- esid: sec-temporal.duration.compare description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + // The following are all valid strings so should not throw: ["UTC", "+01:00"].forEach((timeZone) => { Temporal.Duration.compare(new Temporal.Duration(), new Temporal.Duration(), { relativeTo: { year: 2000, month: 5, day: 2, timeZone } }); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Duration/prototype/add/relativeto-propertybag-timezone-string.js b/test/built-ins/Temporal/Duration/prototype/add/relativeto-propertybag-timezone-string.js index 44448beab8..3b32cf8b24 100644 --- a/test/built-ins/Temporal/Duration/prototype/add/relativeto-propertybag-timezone-string.js +++ b/test/built-ins/Temporal/Duration/prototype/add/relativeto-propertybag-timezone-string.js @@ -4,9 +4,27 @@ /*--- esid: sec-temporal.duration.prototype.add description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance = new Temporal.Duration(1); // The following are all valid strings so should not throw: @@ -14,3 +32,6 @@ const instance = new Temporal.Duration(1); ["UTC", "+01:00"].forEach((timeZone) => { instance.add(new Temporal.Duration(1), { relativeTo: { year: 2000, month: 5, day: 2, timeZone } }); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Duration/prototype/round/relativeto-propertybag-timezone-string.js b/test/built-ins/Temporal/Duration/prototype/round/relativeto-propertybag-timezone-string.js index a279c3cdea..2061506da3 100644 --- a/test/built-ins/Temporal/Duration/prototype/round/relativeto-propertybag-timezone-string.js +++ b/test/built-ins/Temporal/Duration/prototype/round/relativeto-propertybag-timezone-string.js @@ -4,9 +4,27 @@ /*--- esid: sec-temporal.duration.prototype.round description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance = new Temporal.Duration(1); // The following are all valid strings so should not throw: @@ -14,3 +32,6 @@ const instance = new Temporal.Duration(1); ["UTC", "+01:00"].forEach((timeZone) => { instance.round({ largestUnit: "months", relativeTo: { year: 2000, month: 5, day: 2, timeZone } }); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Duration/prototype/subtract/relativeto-propertybag-timezone-string.js b/test/built-ins/Temporal/Duration/prototype/subtract/relativeto-propertybag-timezone-string.js index 48dacac769..c05acabb35 100644 --- a/test/built-ins/Temporal/Duration/prototype/subtract/relativeto-propertybag-timezone-string.js +++ b/test/built-ins/Temporal/Duration/prototype/subtract/relativeto-propertybag-timezone-string.js @@ -4,9 +4,27 @@ /*--- esid: sec-temporal.duration.prototype.subtract description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance = new Temporal.Duration(1); // The following are all valid strings so should not throw: @@ -14,3 +32,6 @@ const instance = new Temporal.Duration(1); ["UTC", "+01:00"].forEach((timeZone) => { instance.subtract(new Temporal.Duration(1), { relativeTo: { year: 2000, month: 5, day: 2, timeZone } }); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Duration/prototype/total/relativeto-propertybag-timezone-string.js b/test/built-ins/Temporal/Duration/prototype/total/relativeto-propertybag-timezone-string.js index 9269225e56..4bd5209ab9 100644 --- a/test/built-ins/Temporal/Duration/prototype/total/relativeto-propertybag-timezone-string.js +++ b/test/built-ins/Temporal/Duration/prototype/total/relativeto-propertybag-timezone-string.js @@ -4,9 +4,27 @@ /*--- esid: sec-temporal.duration.prototype.total description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance = new Temporal.Duration(1); // The following are all valid strings so should not throw: @@ -14,3 +32,6 @@ const instance = new Temporal.Duration(1); ["UTC", "+01:00"].forEach((timeZone) => { instance.total({ unit: "months", relativeTo: { year: 2000, month: 5, day: 2, timeZone } }); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Instant/prototype/toJSON/timezone-getoffsetnanosecondsfor-not-callable.js b/test/built-ins/Temporal/Instant/prototype/toJSON/timezone-getoffsetnanosecondsfor-not-callable.js deleted file mode 100644 index e906dea0e8..0000000000 --- a/test/built-ins/Temporal/Instant/prototype/toJSON/timezone-getoffsetnanosecondsfor-not-callable.js +++ /dev/null @@ -1,19 +0,0 @@ -// 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.tojson -description: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable -features: [BigInt, Symbol, Temporal, arrow-function] ----*/ - -const instance = new Temporal.Instant(1_000_000_000_987_654_321n); - -[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach((notCallable) => { - Temporal.TimeZone.prototype.getOffsetNanosecondsFor = notCallable; - assert.throws( - TypeError, - () => instance.toJSON(), - `Uncallable ${notCallable === null ? 'null' : typeof notCallable} getOffsetNanosecondsFor should throw TypeError` - ); -}); diff --git a/test/built-ins/Temporal/Instant/prototype/toString/timezone-string.js b/test/built-ins/Temporal/Instant/prototype/toString/timezone-string.js index 9c7ba8d863..9c6346a65c 100644 --- a/test/built-ins/Temporal/Instant/prototype/toString/timezone-string.js +++ b/test/built-ins/Temporal/Instant/prototype/toString/timezone-string.js @@ -4,9 +4,27 @@ /*--- esid: sec-temporal.instant.prototype.tostring description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance = new Temporal.Instant(0n); const result1 = instance.toString({ timeZone: "UTC" }); @@ -14,3 +32,6 @@ assert.sameValue(result1.substr(-6), "+00:00", "Time zone created from string 'U const result2 = instance.toString({ timeZone: "-01:30" }); assert.sameValue(result2.substr(-6), "-01:30", "Time zone created from string '-01:30'"); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Instant/prototype/toZonedDateTime/timezone-string.js b/test/built-ins/Temporal/Instant/prototype/toZonedDateTime/timezone-string.js index 0b866b6b81..9893e1fa82 100644 --- a/test/built-ins/Temporal/Instant/prototype/toZonedDateTime/timezone-string.js +++ b/test/built-ins/Temporal/Instant/prototype/toZonedDateTime/timezone-string.js @@ -4,12 +4,33 @@ /*--- esid: sec-temporal.instant.prototype.tozoneddatetime description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance = new Temporal.Instant(0n); ["UTC", "+01:30"].forEach((timeZone) => { const result = instance.toZonedDateTime({ timeZone, calendar: "iso8601" }); assert.sameValue(result.getISOFields().timeZone, timeZone, `time zone slot should store string "${timeZone}"`); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Instant/prototype/toZonedDateTimeISO/timezone-string.js b/test/built-ins/Temporal/Instant/prototype/toZonedDateTimeISO/timezone-string.js index 955a41e9d2..1c4d9b66c8 100644 --- a/test/built-ins/Temporal/Instant/prototype/toZonedDateTimeISO/timezone-string.js +++ b/test/built-ins/Temporal/Instant/prototype/toZonedDateTimeISO/timezone-string.js @@ -4,12 +4,33 @@ /*--- esid: sec-temporal.instant.prototype.tozoneddatetimeiso description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance = new Temporal.Instant(0n); ["UTC", "+01:30"].forEach((timeZone) => { const result = instance.toZonedDateTimeISO(timeZone); assert.sameValue(result.getISOFields().timeZone, timeZone, `time zone slot should store string "${timeZone}"`); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Now/plainDate/timezone-string.js b/test/built-ins/Temporal/Now/plainDate/timezone-string.js index 60aff45c34..877d14dbd0 100644 --- a/test/built-ins/Temporal/Now/plainDate/timezone-string.js +++ b/test/built-ins/Temporal/Now/plainDate/timezone-string.js @@ -4,11 +4,32 @@ /*--- esid: sec-temporal.now.plaindate description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + // The following are all valid strings so should not throw: ["UTC", "+01:00"].forEach((timeZone) => { Temporal.Now.plainDate("iso8601", timeZone); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Now/plainDateISO/timezone-string.js b/test/built-ins/Temporal/Now/plainDateISO/timezone-string.js index d9a452e2df..0062a04bac 100644 --- a/test/built-ins/Temporal/Now/plainDateISO/timezone-string.js +++ b/test/built-ins/Temporal/Now/plainDateISO/timezone-string.js @@ -4,11 +4,32 @@ /*--- esid: sec-temporal.now.plaindateiso description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + // The following are all valid strings so should not throw: ["UTC", "+01:00"].forEach((timeZone) => { Temporal.Now.plainDateISO(timeZone); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Now/plainDateTime/timezone-string.js b/test/built-ins/Temporal/Now/plainDateTime/timezone-string.js index 1b4c0d10ec..23420d4cd1 100644 --- a/test/built-ins/Temporal/Now/plainDateTime/timezone-string.js +++ b/test/built-ins/Temporal/Now/plainDateTime/timezone-string.js @@ -4,11 +4,32 @@ /*--- esid: sec-temporal.now.plaindatetime description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + // The following are all valid strings so should not throw: ["UTC", "+01:00"].forEach((timeZone) => { Temporal.Now.plainDateTime("iso8601", timeZone); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Now/plainDateTimeISO/timezone-string.js b/test/built-ins/Temporal/Now/plainDateTimeISO/timezone-string.js index a4aebae5a5..2cdab47af0 100644 --- a/test/built-ins/Temporal/Now/plainDateTimeISO/timezone-string.js +++ b/test/built-ins/Temporal/Now/plainDateTimeISO/timezone-string.js @@ -4,11 +4,32 @@ /*--- esid: sec-temporal.now.plaindatetimeiso description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + // The following are all valid strings so should not throw: ["UTC", "+01:00"].forEach((timeZone) => { Temporal.Now.plainDateTimeISO(timeZone); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Now/plainTimeISO/timezone-string.js b/test/built-ins/Temporal/Now/plainTimeISO/timezone-string.js index 939f6afa0a..a8fa8c3713 100644 --- a/test/built-ins/Temporal/Now/plainTimeISO/timezone-string.js +++ b/test/built-ins/Temporal/Now/plainTimeISO/timezone-string.js @@ -4,11 +4,32 @@ /*--- esid: sec-temporal.now.plaintimeiso description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + // The following are all valid strings so should not throw: ["UTC", "+01:00"].forEach((timeZone) => { Temporal.Now.plainTimeISO(timeZone); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Now/zonedDateTime/timezone-string.js b/test/built-ins/Temporal/Now/zonedDateTime/timezone-string.js index 5a60defc75..773fc66735 100644 --- a/test/built-ins/Temporal/Now/zonedDateTime/timezone-string.js +++ b/test/built-ins/Temporal/Now/zonedDateTime/timezone-string.js @@ -4,10 +4,31 @@ /*--- esid: sec-temporal.now.zoneddatetime description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + ["UTC", "+01:30"].forEach((timeZone) => { const result = Temporal.Now.zonedDateTime("iso8601", timeZone); assert.sameValue(result.getISOFields().timeZone, timeZone, `Time zone created from string "${timeZone}"`); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/Now/zonedDateTimeISO/timezone-string.js b/test/built-ins/Temporal/Now/zonedDateTimeISO/timezone-string.js index 89a99e175a..9ec4d1b278 100644 --- a/test/built-ins/Temporal/Now/zonedDateTimeISO/timezone-string.js +++ b/test/built-ins/Temporal/Now/zonedDateTimeISO/timezone-string.js @@ -4,10 +4,31 @@ /*--- esid: sec-temporal.now.zoneddatetimeiso description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + ["UTC", "+01:30"].forEach((timeZone) => { const result = Temporal.Now.zonedDateTimeISO(timeZone); assert.sameValue(result.getISOFields().timeZone, timeZone, `Time zone created from string "${timeZone}"`); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/PlainDate/prototype/toZonedDateTime/timezone-string.js b/test/built-ins/Temporal/PlainDate/prototype/toZonedDateTime/timezone-string.js index fb5bb7f955..6e4036ef43 100644 --- a/test/built-ins/Temporal/PlainDate/prototype/toZonedDateTime/timezone-string.js +++ b/test/built-ins/Temporal/PlainDate/prototype/toZonedDateTime/timezone-string.js @@ -4,12 +4,33 @@ /*--- esid: sec-temporal.plaindate.prototype.tozoneddatetime description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance = new Temporal.PlainDate(2000, 5, 2); ["UTC", "+01:30"].forEach((timeZone) => { const result = instance.toZonedDateTime(timeZone); assert.sameValue(result.getISOFields().timeZone, timeZone, `time zone slot should store string "${timeZone}"`); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/PlainDateTime/prototype/toZonedDateTime/timezone-string.js b/test/built-ins/Temporal/PlainDateTime/prototype/toZonedDateTime/timezone-string.js index 8f5c47bc23..c685234e9c 100644 --- a/test/built-ins/Temporal/PlainDateTime/prototype/toZonedDateTime/timezone-string.js +++ b/test/built-ins/Temporal/PlainDateTime/prototype/toZonedDateTime/timezone-string.js @@ -4,12 +4,33 @@ /*--- esid: sec-temporal.plaindatetime.prototype.tozoneddatetime description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance = new Temporal.PlainDateTime(2000, 5, 2); ["UTC", "+01:30"].forEach((timeZone) => { const result = instance.toZonedDateTime(timeZone); assert.sameValue(result.getISOFields().timeZone, timeZone, `time zone slot should store string "${timeZone}"`); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/PlainTime/prototype/toZonedDateTime/timezone-string.js b/test/built-ins/Temporal/PlainTime/prototype/toZonedDateTime/timezone-string.js index 0edaf41993..6e3de214a8 100644 --- a/test/built-ins/Temporal/PlainTime/prototype/toZonedDateTime/timezone-string.js +++ b/test/built-ins/Temporal/PlainTime/prototype/toZonedDateTime/timezone-string.js @@ -4,12 +4,33 @@ /*--- esid: sec-temporal.plaintime.prototype.tozoneddatetime description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance = new Temporal.PlainTime(); ["UTC", "+01:30"].forEach((timeZone) => { const result = instance.toZonedDateTime({ plainDate: new Temporal.PlainDate(2000, 5, 2), timeZone }); assert.sameValue(result.getISOFields().timeZone, timeZone, `time zone slot should store string "${timeZone}"`); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/TimeZone/from/timezone-string.js b/test/built-ins/Temporal/TimeZone/from/timezone-string.js index 8be5cee002..38189494e5 100644 --- a/test/built-ins/Temporal/TimeZone/from/timezone-string.js +++ b/test/built-ins/Temporal/TimeZone/from/timezone-string.js @@ -4,10 +4,31 @@ /*--- esid: sec-temporal.timezone.from description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + ["UTC", "+01:30"].forEach((timeZone) => { const result = Temporal.TimeZone.from(timeZone); assert.sameValue(result.id, timeZone, `Time zone created from string "${timeZone}"`); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/compare/argument-propertybag-timezone-string.js b/test/built-ins/Temporal/ZonedDateTime/compare/argument-propertybag-timezone-string.js index 1a94c074a5..e5f1be57ff 100644 --- a/test/built-ins/Temporal/ZonedDateTime/compare/argument-propertybag-timezone-string.js +++ b/test/built-ins/Temporal/ZonedDateTime/compare/argument-propertybag-timezone-string.js @@ -4,9 +4,27 @@ /*--- esid: sec-temporal.zoneddatetime.compare description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + ["UTC", "+01:30"].forEach((timeZone) => { const epoch = new Temporal.ZonedDateTime(0n, new Temporal.TimeZone(timeZone)); @@ -14,3 +32,6 @@ features: [Temporal] Temporal.ZonedDateTime.compare({ year: 2020, month: 5, day: 2, timeZone }, epoch); Temporal.ZonedDateTime.compare(epoch, { year: 2020, month: 5, day: 2, timeZone }); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/from/argument-propertybag-timezone-string.js b/test/built-ins/Temporal/ZonedDateTime/from/argument-propertybag-timezone-string.js index 1be3bbe5d6..a0a4175926 100644 --- a/test/built-ins/Temporal/ZonedDateTime/from/argument-propertybag-timezone-string.js +++ b/test/built-ins/Temporal/ZonedDateTime/from/argument-propertybag-timezone-string.js @@ -4,10 +4,31 @@ /*--- esid: sec-temporal.zoneddatetime.from description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + ["UTC", "+01:30"].forEach((timeZone) => { const result = Temporal.ZonedDateTime.from({ year: 2000, month: 5, day: 2, timeZone }); assert.sameValue(result.getISOFields().timeZone, timeZone, `Time zone created from string "${timeZone}"`); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/add/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/add/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..9e5e22d980 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/add/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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.add +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.add(new Temporal.Duration(1)); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/day/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/day/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..46c6ed54eb --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/day/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.day +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.day; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/dayOfWeek/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/dayOfWeek/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..935614eff3 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/dayOfWeek/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.dayofweek +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.dayOfWeek; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/dayOfYear/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/dayOfYear/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..dec583d631 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/dayOfYear/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.dayofyear +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.dayOfYear; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/daysInMonth/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/daysInMonth/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..80b9481e4c --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/daysInMonth/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.daysinmonth +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.daysInMonth; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/daysInWeek/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/daysInWeek/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..ef010891d5 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/daysInWeek/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.daysinweek +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.daysInWeek; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/daysInYear/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/daysInYear/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..bd57ba8061 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/daysInYear/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.daysinyear +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.daysInYear; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/equals/argument-propertybag-timezone-string.js b/test/built-ins/Temporal/ZonedDateTime/prototype/equals/argument-propertybag-timezone-string.js index a8039bf329..57de6c0244 100644 --- a/test/built-ins/Temporal/ZonedDateTime/prototype/equals/argument-propertybag-timezone-string.js +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/equals/argument-propertybag-timezone-string.js @@ -4,11 +4,32 @@ /*--- esid: sec-temporal.zoneddatetime.prototype.equals description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance1 = new Temporal.ZonedDateTime(0n, new Temporal.TimeZone("UTC")); assert(instance1.equals({ year: 1970, month: 1, day: 1, timeZone: "UTC" }), "Time zone created from string 'UTC'"); const instance2 = new Temporal.ZonedDateTime(0n, new Temporal.TimeZone("-01:30")); assert(instance2.equals({ year: 1969, month: 12, day: 31, hour: 22, minute: 30, timeZone: "-01:30" }), "Time zone created from string '-01:30'"); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/equals/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/equals/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..6c8a4188bb --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/equals/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const idOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "id"); +Object.defineProperty(Temporal.TimeZone.prototype, "id", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("id should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.equals(new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC")); + +Object.defineProperty(Temporal.TimeZone.prototype, "id", idOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/getISOFields/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/getISOFields/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..d4384733e6 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/getISOFields/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.getisofields +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.getISOFields(); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/hour/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/hour/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..e34f3fc6b5 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/hour/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.hour +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.hour; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/inLeapYear/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/inLeapYear/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..7de82ddce3 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/inLeapYear/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.inleapyear +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.inLeapYear; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/microsecond/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/microsecond/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..2a4fce9dcd --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/microsecond/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.microsecond +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.microsecond; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/millisecond/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/millisecond/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..118840853d --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/millisecond/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.millisecond +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.millisecond; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/minute/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/minute/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..b3caf18e34 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/minute/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.minute +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.minute; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/month/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/month/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..ed00a42a10 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/month/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.month +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.month; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/monthCode/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/monthCode/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..11e3f269a0 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/monthCode/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.monthcode +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.monthCode; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/monthsInYear/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/monthsInYear/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..ecced9bc89 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/monthsInYear/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.monthsinyear +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.monthsInYear; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/nanosecond/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/nanosecond/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..ad09cfacb4 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/nanosecond/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.nanosecond +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.nanosecond; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/offset/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/offset/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..64cd54cb41 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/offset/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.offset +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.offset; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/offsetNanoseconds/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/offsetNanoseconds/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..a8ed9865a8 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/offsetNanoseconds/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.offsetnanoseconds +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.offsetNanoseconds; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/round/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/round/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..437977d999 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/round/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.round("day"); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/second/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/second/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..fcae38ebce --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/second/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.second +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.second; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/since/argument-propertybag-timezone-string.js b/test/built-ins/Temporal/ZonedDateTime/prototype/since/argument-propertybag-timezone-string.js index 39d985a818..bc33b46d39 100644 --- a/test/built-ins/Temporal/ZonedDateTime/prototype/since/argument-propertybag-timezone-string.js +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/since/argument-propertybag-timezone-string.js @@ -4,11 +4,32 @@ /*--- esid: sec-temporal.zoneddatetime.prototype.since description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance1 = new Temporal.ZonedDateTime(0n, new Temporal.TimeZone("UTC")); assert(instance1.since({ year: 1970, month: 1, day: 1, timeZone: "UTC" }).blank, "Time zone created from string 'UTC'"); const instance2 = new Temporal.ZonedDateTime(0n, new Temporal.TimeZone("-01:30")); assert(instance2.since({ year: 1969, month: 12, day: 31, hour: 22, minute: 30, timeZone: "-01:30" }).blank, "Time zone created from string '-01:30'"); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/since/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/since/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..3b7e4ac0f0 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/since/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.since(new Temporal.ZonedDateTime(0n, "UTC")); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/startOfDay/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/startOfDay/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..60141122a2 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/startOfDay/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.startOfDay(); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/subtract/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/subtract/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..1d1f7f974a --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/subtract/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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.subtract +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.subtract(new Temporal.Duration(1)); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/timeZoneId/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/timeZoneId/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..f7ec46285c --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/timeZoneId/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.timezoneid +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const idOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "id"); +Object.defineProperty(Temporal.TimeZone.prototype, "id", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("id should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.timeZoneId; + +Object.defineProperty(Temporal.TimeZone.prototype, "id", idOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/toJSON/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/toJSON/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..8f5de5a560 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/toJSON/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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.tojson +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const idOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "id"); +Object.defineProperty(Temporal.TimeZone.prototype, "id", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("id should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.toJSON(); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "id", idOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/toLocaleString/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/toLocaleString/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..00ff2997c1 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/toLocaleString/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const idOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "id"); +Object.defineProperty(Temporal.TimeZone.prototype, "id", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("id should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.toLocaleString(); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "id", idOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainDate/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainDate/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..cf4cb037cf --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainDate/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.toplaindate +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.toPlainDate(); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainDateTime/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainDateTime/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..afaabb6410 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainDateTime/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.toplaindatetime +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.toPlainDateTime(); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainMonthDay/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainMonthDay/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..96f1a3c5e6 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainMonthDay/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.toplainmonthday +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.toPlainMonthDay(); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainTime/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainTime/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..04fac73de9 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainTime/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.toplaintime +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.toPlainTime(); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainYearMonth/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainYearMonth/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..58916e5576 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/toPlainYearMonth/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.toplainyearmonth +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.toPlainYearMonth(); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/toString/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/toString/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..3768274983 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/toString/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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.tostring +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const idOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "id"); +Object.defineProperty(Temporal.TimeZone.prototype, "id", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("id should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.toString(); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "id", idOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/until/argument-propertybag-timezone-string.js b/test/built-ins/Temporal/ZonedDateTime/prototype/until/argument-propertybag-timezone-string.js index 24ff2b4ce2..3e6f906f49 100644 --- a/test/built-ins/Temporal/ZonedDateTime/prototype/until/argument-propertybag-timezone-string.js +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/until/argument-propertybag-timezone-string.js @@ -4,11 +4,32 @@ /*--- esid: sec-temporal.zoneddatetime.prototype.until description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance1 = new Temporal.ZonedDateTime(0n, new Temporal.TimeZone("UTC")); assert(instance1.until({ year: 1970, month: 1, day: 1, timeZone: "UTC" }).blank, "Time zone created from string 'UTC'"); const instance2 = new Temporal.ZonedDateTime(0n, new Temporal.TimeZone("-01:30")); assert(instance2.until({ year: 1969, month: 12, day: 31, hour: 22, minute: 30, timeZone: "-01:30" }).blank, "Time zone created from string '-01:30'"); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/until/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/until/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..369dddc462 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/until/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.until(new Temporal.ZonedDateTime(1_100_000_000_000_000_000n, "UTC")); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/weekOfYear/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/weekOfYear/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..249c94c771 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/weekOfYear/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.weekofyear +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.weekOfYear; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/with/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/with/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..ed8075079b --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/with/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.with({ year: 2001 }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/withPlainDate/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/withPlainDate/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..11a9044fb5 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/withPlainDate/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.withPlainDate(new Temporal.PlainDate(2001, 6, 13)); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/withPlainTime/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/withPlainTime/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..47fef97276 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/withPlainTime/builtin-timezone-no-observable-calls.js @@ -0,0 +1,34 @@ +// 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: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.withPlainTime(new Temporal.PlainTime(12, 34, 56)); + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/withTimeZone/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/withTimeZone/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..83ef378332 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/withTimeZone/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.withtimezone +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const idOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "id"); +Object.defineProperty(Temporal.TimeZone.prototype, "id", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("id should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.withTimeZone("+01:00"); + +Object.defineProperty(Temporal.TimeZone.prototype, "id", idOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/withTimeZone/timezone-string.js b/test/built-ins/Temporal/ZonedDateTime/prototype/withTimeZone/timezone-string.js index f80b924473..d99aed5767 100644 --- a/test/built-ins/Temporal/ZonedDateTime/prototype/withTimeZone/timezone-string.js +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/withTimeZone/timezone-string.js @@ -4,12 +4,33 @@ /*--- esid: sec-temporal.zoneddatetime.prototype.withtimezone description: Time zone IDs are valid input for a time zone +includes: [temporalHelpers.js] features: [Temporal] ---*/ +const getPossibleInstantsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getPossibleInstantsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be looked up"); + }, +}); +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + const instance = new Temporal.ZonedDateTime(0n, "UTC"); ["UTC", "+01:30"].forEach((timeZone) => { const result = instance.withTimeZone(timeZone); assert.sameValue(result.getISOFields().timeZone, timeZone, `time zone slot should store string "${timeZone}"`); }); + +Object.defineProperty(Temporal.TimeZone.prototype, "getPossibleInstantsFor", getPossibleInstantsForOriginal); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/year/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/year/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..79422e52aa --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/year/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.year +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.year; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/built-ins/Temporal/ZonedDateTime/prototype/yearOfWeek/builtin-timezone-no-observable-calls.js b/test/built-ins/Temporal/ZonedDateTime/prototype/yearOfWeek/builtin-timezone-no-observable-calls.js new file mode 100644 index 0000000000..dd3f512d83 --- /dev/null +++ b/test/built-ins/Temporal/ZonedDateTime/prototype/yearOfWeek/builtin-timezone-no-observable-calls.js @@ -0,0 +1,25 @@ +// 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.yearofweek +description: > + Calling the method on an instance constructed with a builtin time zone causes + no observable lookups or calls to time zone methods. +includes: [temporalHelpers.js] +features: [Temporal] +---*/ + +const getOffsetNanosecondsForOriginal = Object.getOwnPropertyDescriptor(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor"); +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", { + configurable: true, + enumerable: false, + get() { + TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be looked up"); + }, +}); + +const instance = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); +instance.yearOfWeek; + +Object.defineProperty(Temporal.TimeZone.prototype, "getOffsetNanosecondsFor", getOffsetNanosecondsForOriginal); diff --git a/test/intl402/DateTimeFormat/prototype/format/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js b/test/intl402/DateTimeFormat/prototype/format/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js deleted file mode 100644 index 2777a2c9ff..0000000000 --- a/test/intl402/DateTimeFormat/prototype/format/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright (C) 2021 Igalia, S.L. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. - -/*--- -esid: sec-datetime-format-functions -description: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable -features: [Temporal] ----*/ - -const formatter = new Intl.DateTimeFormat(undefined, { calendar: "iso8601" }); -const date = new Temporal.PlainDate(2021, 8, 4); -const datetime = new Temporal.PlainDateTime(2021, 8, 4, 0, 30, 45, 123, 456, 789); -const monthDay = new Temporal.PlainMonthDay(8, 4); -const time = new Temporal.PlainTime(0, 30, 45, 123, 456, 789); -const month = new Temporal.PlainYearMonth(2021, 8); - -Temporal.TimeZone.prototype.getPossibleInstantsFor = function () { - return []; -}; - -[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach(notCallable => { - Temporal.TimeZone.prototype.getOffsetNanosecondsFor = notCallable; - - assert.throws( - TypeError, - () => formatter.format(date), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainDate case)" - ); - assert.throws( - TypeError, - () => formatter.format(datetime), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainDateTime case)" - ); - assert.throws( - TypeError, - () => formatter.format(monthDay), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainMonthDay case)" - ); - assert.throws( - TypeError, - () => formatter.format(time), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainTime case)" - ); - assert.throws( - TypeError, - () => formatter.format(month), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainYearMonth case)" - ); -}); diff --git a/test/intl402/DateTimeFormat/prototype/formatRange/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js b/test/intl402/DateTimeFormat/prototype/formatRange/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js deleted file mode 100644 index 560cf9b6f4..0000000000 --- a/test/intl402/DateTimeFormat/prototype/formatRange/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js +++ /dev/null @@ -1,54 +0,0 @@ -// Copyright (C) 2021 Igalia, S.L. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. - -/*--- -esid: sec-intl.datetimeformat.prototype.formatRange -description: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable -features: [Temporal] ----*/ - -const formatter = new Intl.DateTimeFormat(undefined, { calendar: "iso8601" }); -const date1 = new Temporal.PlainDate(2021, 8, 4); -const date2 = new Temporal.PlainDate(2021, 9, 4); -const datetime1 = new Temporal.PlainDateTime(2021, 8, 4, 0, 30, 45, 123, 456, 789); -const datetime2 = new Temporal.PlainDateTime(2021, 9, 4, 0, 30, 45, 123, 456, 789); -const monthDay1 = new Temporal.PlainMonthDay(8, 4); -const monthDay2 = new Temporal.PlainMonthDay(9, 4); -const time1 = new Temporal.PlainTime(0, 30, 45, 123, 456, 789); -const time2 = new Temporal.PlainTime(1, 30, 45, 123, 456, 789); -const month1 = new Temporal.PlainYearMonth(2021, 8); -const month2 = new Temporal.PlainYearMonth(2022, 8); - -Temporal.TimeZone.prototype.getPossibleInstantsFor = function () { - return []; -}; - -[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach(notCallable => { - Temporal.TimeZone.prototype.getOffsetNanosecondsFor = notCallable; - - assert.throws( - TypeError, - () => formatter.formatRange(date1, date2), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainDate case)" - ); - assert.throws( - TypeError, - () => formatter.formatRange(datetime1, datetime2), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainDateTime case)" - ); - assert.throws( - TypeError, - () => formatter.formatRange(monthDay1, monthDay2), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainMonthDay case)" - ); - assert.throws( - TypeError, - () => formatter.formatRange(time1, time2), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainTime case)" - ); - assert.throws( - TypeError, - () => formatter.formatRange(month1, month2), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainYearMonth case)" - ); -}); diff --git a/test/intl402/DateTimeFormat/prototype/formatRangeToParts/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js b/test/intl402/DateTimeFormat/prototype/formatRangeToParts/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js deleted file mode 100644 index 600ce00c82..0000000000 --- a/test/intl402/DateTimeFormat/prototype/formatRangeToParts/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js +++ /dev/null @@ -1,54 +0,0 @@ -// Copyright (C) 2021 Igalia, S.L. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. - -/*--- -esid: sec-Intl.DateTimeFormat.prototype.formatRangeToParts -description: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable -features: [Temporal] ----*/ - -const formatter = new Intl.DateTimeFormat(undefined, { calendar: "iso8601" }); -const date1 = new Temporal.PlainDate(2021, 8, 4); -const date2 = new Temporal.PlainDate(2021, 9, 4); -const datetime1 = new Temporal.PlainDateTime(2021, 8, 4, 0, 30, 45, 123, 456, 789); -const datetime2 = new Temporal.PlainDateTime(2021, 9, 4, 0, 30, 45, 123, 456, 789); -const monthDay1 = new Temporal.PlainMonthDay(8, 4); -const monthDay2 = new Temporal.PlainMonthDay(9, 4); -const time1 = new Temporal.PlainTime(0, 30, 45, 123, 456, 789); -const time2 = new Temporal.PlainTime(1, 30, 45, 123, 456, 789); -const month1 = new Temporal.PlainYearMonth(2021, 8); -const month2 = new Temporal.PlainYearMonth(2022, 8); - -Temporal.TimeZone.prototype.getPossibleInstantsFor = function () { - return []; -}; - -[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach(notCallable => { - Temporal.TimeZone.prototype.getOffsetNanosecondsFor = notCallable; - - assert.throws( - TypeError, - () => formatter.formatRangeToParts(date1, date2), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainDate case)" - ); - assert.throws( - TypeError, - () => formatter.formatRangeToParts(datetime1, datetime2), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainDateTime case)" - ); - assert.throws( - TypeError, - () => formatter.formatRangeToParts(monthDay1, monthDay2), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainMonthDay case)" - ); - assert.throws( - TypeError, - () => formatter.formatRangeToParts(time1, time2), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainTime case)" - ); - assert.throws( - TypeError, - () => formatter.formatRangeToParts(month1, month2), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainYearMonth case)" - ); -}); diff --git a/test/intl402/DateTimeFormat/prototype/formatToParts/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js b/test/intl402/DateTimeFormat/prototype/formatToParts/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js deleted file mode 100644 index 82c5706a27..0000000000 --- a/test/intl402/DateTimeFormat/prototype/formatToParts/temporal-objects-timezone-getoffsetnanosecondsfor-not-callable.js +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright (C) 2021 Igalia, S.L. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. - -/*--- -esid: sec-Intl.DateTimeFormat.prototype.formatToParts -description: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable -features: [Temporal] ----*/ - -const formatter = new Intl.DateTimeFormat(undefined, { calendar: "iso8601" }); -const date = new Temporal.PlainDate(2021, 8, 4); -const datetime = new Temporal.PlainDateTime(2021, 8, 4, 0, 30, 45, 123, 456, 789); -const monthDay = new Temporal.PlainMonthDay(8, 4); -const time = new Temporal.PlainTime(0, 30, 45, 123, 456, 789); -const month = new Temporal.PlainYearMonth(2021, 8); - -Temporal.TimeZone.prototype.getPossibleInstantsFor = function () { - return []; -}; - -[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach(notCallable => { - Temporal.TimeZone.prototype.getOffsetNanosecondsFor = notCallable; - - assert.throws( - TypeError, - () => formatter.formatToParts(date), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainDate case)" - ); - assert.throws( - TypeError, - () => formatter.formatToParts(datetime), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainDateTime case)" - ); - assert.throws( - TypeError, - () => formatter.formatToParts(monthDay), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainMonthDay case)" - ); - assert.throws( - TypeError, - () => formatter.formatToParts(time), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainTime case)" - ); - assert.throws( - TypeError, - () => formatter.formatToParts(month), - "Uncallable getOffsetNanosecondsFor should throw TypeError (PlainYearMonth case)" - ); -}); diff --git a/test/intl402/Temporal/Now/zonedDateTime/calendar-string.js b/test/intl402/Temporal/Now/zonedDateTime/calendar-string.js index 805b20764b..0fdd7097bf 100644 --- a/test/intl402/Temporal/Now/zonedDateTime/calendar-string.js +++ b/test/intl402/Temporal/Now/zonedDateTime/calendar-string.js @@ -12,4 +12,5 @@ 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); diff --git a/test/intl402/Temporal/Now/zonedDateTime/calendar-timezone-string.js b/test/intl402/Temporal/Now/zonedDateTime/calendar-timezone-string.js index f973daaba4..76d9962d0e 100644 --- a/test/intl402/Temporal/Now/zonedDateTime/calendar-timezone-string.js +++ b/test/intl402/Temporal/Now/zonedDateTime/calendar-timezone-string.js @@ -11,4 +11,5 @@ 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"); diff --git a/test/intl402/Temporal/Now/zonedDateTimeISO/timezone-string.js b/test/intl402/Temporal/Now/zonedDateTimeISO/timezone-string.js index 1d6445b448..79a59151e3 100644 --- a/test/intl402/Temporal/Now/zonedDateTimeISO/timezone-string.js +++ b/test/intl402/Temporal/Now/zonedDateTimeISO/timezone-string.js @@ -11,4 +11,5 @@ 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"); diff --git a/test/intl402/Temporal/PlainDate/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js b/test/intl402/Temporal/PlainDate/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js deleted file mode 100644 index fe76845955..0000000000 --- a/test/intl402/Temporal/PlainDate/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js +++ /dev/null @@ -1,22 +0,0 @@ -// 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: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable -features: [BigInt, Symbol, Temporal, arrow-function] ----*/ - -const instance = new Temporal.PlainDate(2000, 5, 2); -Temporal.TimeZone.prototype.getPossibleInstantsFor = function () { - return []; -}; - -[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach((notCallable) => { - Temporal.TimeZone.prototype.getOffsetNanosecondsFor = notCallable; - assert.throws( - TypeError, - () => instance.toLocaleString(), - `Uncallable ${notCallable === null ? 'null' : typeof notCallable} getOffsetNanosecondsFor should throw TypeError` - ); -}); diff --git a/test/intl402/Temporal/PlainDateTime/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js b/test/intl402/Temporal/PlainDateTime/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js deleted file mode 100644 index 1d090307e4..0000000000 --- a/test/intl402/Temporal/PlainDateTime/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js +++ /dev/null @@ -1,22 +0,0 @@ -// 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: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable -features: [BigInt, Symbol, Temporal, arrow-function] ----*/ - -const instance = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321); -Temporal.TimeZone.prototype.getPossibleInstantsFor = function () { - return []; -}; - -[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach((notCallable) => { - Temporal.TimeZone.prototype.getOffsetNanosecondsFor = notCallable; - assert.throws( - TypeError, - () => instance.toLocaleString(), - `Uncallable ${notCallable === null ? 'null' : typeof notCallable} getOffsetNanosecondsFor should throw TypeError` - ); -}); diff --git a/test/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js b/test/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js deleted file mode 100644 index 73dfc26b9d..0000000000 --- a/test/intl402/Temporal/PlainMonthDay/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js +++ /dev/null @@ -1,22 +0,0 @@ -// 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: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable -features: [BigInt, Symbol, Temporal, arrow-function] ----*/ - -const instance = new Temporal.PlainMonthDay(5, 2); -Temporal.TimeZone.prototype.getPossibleInstantsFor = function () { - return []; -}; - -[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach((notCallable) => { - Temporal.TimeZone.prototype.getOffsetNanosecondsFor = notCallable; - assert.throws( - TypeError, - () => instance.toLocaleString(undefined, { calendar: "iso8601" }), - `Uncallable ${notCallable === null ? 'null' : typeof notCallable} getOffsetNanosecondsFor should throw TypeError` - ); -}); diff --git a/test/intl402/Temporal/PlainTime/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js b/test/intl402/Temporal/PlainTime/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js deleted file mode 100644 index 0abec4a9c8..0000000000 --- a/test/intl402/Temporal/PlainTime/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js +++ /dev/null @@ -1,22 +0,0 @@ -// 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: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable -features: [BigInt, Symbol, Temporal, arrow-function] ----*/ - -const instance = new Temporal.PlainTime(12, 34, 56, 987, 654, 321); -Temporal.TimeZone.prototype.getPossibleInstantsFor = function () { - return []; -}; - -[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach((notCallable) => { - Temporal.TimeZone.prototype.getOffsetNanosecondsFor = notCallable; - assert.throws( - TypeError, - () => instance.toLocaleString(), - `Uncallable ${notCallable === null ? 'null' : typeof notCallable} getOffsetNanosecondsFor should throw TypeError` - ); -}); diff --git a/test/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js b/test/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js deleted file mode 100644 index 4cbde66961..0000000000 --- a/test/intl402/Temporal/PlainYearMonth/prototype/toLocaleString/timezone-getoffsetnanosecondsfor-not-callable.js +++ /dev/null @@ -1,22 +0,0 @@ -// 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: TypeError thrown if timeZone.getOffsetNanosecondsFor is not callable -features: [BigInt, Symbol, Temporal, arrow-function] ----*/ - -const instance = new Temporal.PlainYearMonth(2000, 5); -Temporal.TimeZone.prototype.getPossibleInstantsFor = function () { - return []; -}; - -[undefined, null, true, Math.PI, 'string', Symbol('sym'), 42n, {}].forEach((notCallable) => { - Temporal.TimeZone.prototype.getOffsetNanosecondsFor = notCallable; - assert.throws( - TypeError, - () => instance.toLocaleString(undefined, { calendar: "iso8601" }), - `Uncallable ${notCallable === null ? 'null' : typeof notCallable} getOffsetNanosecondsFor should throw TypeError` - ); -});