From 6a99a28dd81e6bb0ba5a3f769e092e4af1c9a84e Mon Sep 17 00:00:00 2001 From: Aditi Date: Tue, 9 Aug 2022 16:41:13 +0530 Subject: [PATCH] Add proposal-temporal's old demitasse tests to staging --- test/staging/Temporal/Duration/old/add.js | 149 +++ .../Duration/old/compare-no-precision-loss.js | 13 + test/staging/Temporal/Duration/old/limits.js | 92 ++ test/staging/Temporal/Duration/old/round.js | 902 ++++++++++++++++++ .../staging/Temporal/Duration/old/subtract.js | 123 +++ .../staging/Temporal/Duration/old/toString.js | 32 + test/staging/Temporal/Duration/old/total.js | 475 +++++++++ test/staging/Temporal/Regex/old/duration.js | 268 ++++++ test/staging/Temporal/Regex/old/instant.js | 264 +++++ test/staging/Temporal/Regex/old/plaindate.js | 81 ++ .../Temporal/Regex/old/plaindatetime.js | 71 ++ .../Temporal/Regex/old/plainmonthday.js | 75 ++ test/staging/Temporal/Regex/old/plaintime.js | 63 ++ .../Temporal/Regex/old/plainyearmonth.js | 106 ++ test/staging/Temporal/Regex/old/timezone.js | 101 ++ .../Temporal/TimeZone/old/dst-change.js | 26 + .../old/getInstantFor-disambiguation.js | 47 + .../Temporal/TimeZone/old/getInstantFor.js | 58 ++ .../TimeZone/old/getNextTransition.js | 30 + .../TimeZone/old/getPossibleInstantsFor.js | 44 + .../TimeZone/old/getPreviousTransition.js | 24 + .../Temporal/TimeZone/old/subminute-offset.js | 17 + .../TimeZone/old/timezone-america-la.js | 28 + .../Temporal/TimeZone/old/timezone-offset.js | 21 + .../TimeZone/old/timezone-utc-offset.js | 18 + .../UserCalendar/old/calendar-extra-fields.js | 152 +++ .../old/calendar-non-trivial-mergefields.js | 146 +++ .../old/trivial-protocol-implementation.js | 191 ++++ .../UserCalendar/old/trivial-subclass.js | 159 +++ .../UserTimezone/old/subminute-offset.js | 77 ++ .../UserTimezone/old/trivial-protocol.js | 39 + .../UserTimezone/old/trivial-subclass.js | 115 +++ .../staging/Temporal/ZonedDateTime/old/add.js | 50 + .../Temporal/ZonedDateTime/old/compare.js | 120 +++ .../old/construction-and-properties.js | 86 ++ .../old/date-time-hours-overflow.js | 23 + .../Temporal/ZonedDateTime/old/dst-math.js | 290 ++++++ .../ZonedDateTime/old/dst-properties.js | 57 ++ .../Temporal/ZonedDateTime/old/equals.js | 75 ++ .../ZonedDateTime/old/order-of-operations.js | 79 ++ .../ZonedDateTime/old/property-bags.js | 282 ++++++ .../old/reversibility-of-differences.js | 37 + .../Temporal/ZonedDateTime/old/round.js | 348 +++++++ .../Temporal/ZonedDateTime/old/since.js | 516 ++++++++++ .../ZonedDateTime/old/string-parsing.js | 157 +++ .../Temporal/ZonedDateTime/old/subtract.js | 29 + .../Temporal/ZonedDateTime/old/toInstant.js | 33 + .../Temporal/ZonedDateTime/old/toPlainDate.js | 21 + .../ZonedDateTime/old/toPlainMonthDay.js | 21 + .../Temporal/ZonedDateTime/old/toPlainTime.js | 14 + .../ZonedDateTime/old/toPlainYearMonth.js | 21 + .../Temporal/ZonedDateTime/old/toString.js | 71 ++ .../Temporal/ZonedDateTime/old/until.js | 520 ++++++++++ .../Temporal/ZonedDateTime/old/with.js | 267 ++++++ .../ZonedDateTime/old/withCalendar.js | 21 + .../ZonedDateTime/old/withPlainDate.js | 45 + .../ZonedDateTime/old/withPlainTime.js | 26 + .../ZonedDateTime/old/withTimezone.js | 20 + 58 files changed, 7236 insertions(+) create mode 100644 test/staging/Temporal/Duration/old/add.js create mode 100644 test/staging/Temporal/Duration/old/compare-no-precision-loss.js create mode 100644 test/staging/Temporal/Duration/old/limits.js create mode 100644 test/staging/Temporal/Duration/old/round.js create mode 100644 test/staging/Temporal/Duration/old/subtract.js create mode 100644 test/staging/Temporal/Duration/old/toString.js create mode 100644 test/staging/Temporal/Duration/old/total.js create mode 100644 test/staging/Temporal/Regex/old/duration.js create mode 100644 test/staging/Temporal/Regex/old/instant.js create mode 100644 test/staging/Temporal/Regex/old/plaindate.js create mode 100644 test/staging/Temporal/Regex/old/plaindatetime.js create mode 100644 test/staging/Temporal/Regex/old/plainmonthday.js create mode 100644 test/staging/Temporal/Regex/old/plaintime.js create mode 100644 test/staging/Temporal/Regex/old/plainyearmonth.js create mode 100644 test/staging/Temporal/Regex/old/timezone.js create mode 100644 test/staging/Temporal/TimeZone/old/dst-change.js create mode 100644 test/staging/Temporal/TimeZone/old/getInstantFor-disambiguation.js create mode 100644 test/staging/Temporal/TimeZone/old/getInstantFor.js create mode 100644 test/staging/Temporal/TimeZone/old/getNextTransition.js create mode 100644 test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js create mode 100644 test/staging/Temporal/TimeZone/old/getPreviousTransition.js create mode 100644 test/staging/Temporal/TimeZone/old/subminute-offset.js create mode 100644 test/staging/Temporal/TimeZone/old/timezone-america-la.js create mode 100644 test/staging/Temporal/TimeZone/old/timezone-offset.js create mode 100644 test/staging/Temporal/TimeZone/old/timezone-utc-offset.js create mode 100644 test/staging/Temporal/UserCalendar/old/calendar-extra-fields.js create mode 100644 test/staging/Temporal/UserCalendar/old/calendar-non-trivial-mergefields.js create mode 100644 test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js create mode 100644 test/staging/Temporal/UserCalendar/old/trivial-subclass.js create mode 100644 test/staging/Temporal/UserTimezone/old/subminute-offset.js create mode 100644 test/staging/Temporal/UserTimezone/old/trivial-protocol.js create mode 100644 test/staging/Temporal/UserTimezone/old/trivial-subclass.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/add.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/compare.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/construction-and-properties.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/dst-math.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/dst-properties.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/equals.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/order-of-operations.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/property-bags.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/reversibility-of-differences.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/round.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/since.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/string-parsing.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/subtract.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/toInstant.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/toPlainDate.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/toPlainTime.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/toString.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/until.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/with.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/withCalendar.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/withPlainDate.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/withPlainTime.js create mode 100644 test/staging/Temporal/ZonedDateTime/old/withTimezone.js diff --git a/test/staging/Temporal/Duration/old/add.js b/test/staging/Temporal/Duration/old/add.js new file mode 100644 index 0000000000..02868b29bb --- /dev/null +++ b/test/staging/Temporal/Duration/old/add.js @@ -0,0 +1,149 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-duration-objects +description: Temporal.Duration.prototype.add() works as expected +features: [Temporal] +---*/ + +var oneDay = new Temporal.Duration(0, 0, 0, 1); +var hours24 = new Temporal.Duration(0, 0, 0, 0, 24); + +// relativeTo does not affect days if PlainDate +var relativeTo = Temporal.PlainDate.from("2017-01-01"); +assert.sameValue(`${ oneDay.add(hours24, { relativeTo }) }`, "P2D"); + +// relativeTo does not affect days if ZonedDateTime, and duration encompasses no DST change +var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[America/Montevideo]"); +assert.sameValue(`${ oneDay.add(hours24, { relativeTo }) }`, "P2D"); +var skippedHourDay = Temporal.ZonedDateTime.from("2019-03-10T00:00[America/Vancouver]"); +var repeatedHourDay = Temporal.ZonedDateTime.from("2019-11-03T00:00[America/Vancouver]"); +var inRepeatedHour = Temporal.ZonedDateTime.from("2019-11-03T01:00-07:00[America/Vancouver]"); +var hours12 = new Temporal.Duration(0, 0, 0, 0, 12); +var hours25 = new Temporal.Duration(0, 0, 0, 0, 25); + +// relativeTo affects days if ZonedDateTime, and duration encompasses DST change", + +// start inside repeated hour, end after", +assert.sameValue(`${ hours25.add(oneDay, { relativeTo: inRepeatedHour }) }`, "P2D"); +assert.sameValue(`${ oneDay.add(hours25, { relativeTo: inRepeatedHour }) }`, "P2DT1H"); + +// start after repeated hour, end inside (negative)" +var relativeTo = Temporal.ZonedDateTime.from("2019-11-05T01:00[America/Vancouver]"); +assert.sameValue(`${ hours25.negated().add(oneDay.negated(), { relativeTo }) }`, "-P2DT1H"); +assert.sameValue(`${ oneDay.negated().add(hours25.negated(), { relativeTo }) }`, "-P2D"); + +// start inside repeated hour, end in skipped hour", +assert.sameValue(`${ hours25.add(Temporal.Duration.from({ + days: 125, + hours: 1 +}), { relativeTo: inRepeatedHour }) }`, "P126DT1H"); +assert.sameValue(`${ oneDay.add(Temporal.Duration.from({ + days: 125, + hours: 1 +}), { relativeTo: inRepeatedHour }) }`, "P126DT1H"); + +// start in normal hour, end in skipped hour", +var relativeTo = Temporal.ZonedDateTime.from("2019-03-08T02:30[America/Vancouver]"); +assert.sameValue(`${ oneDay.add(hours25, { relativeTo }) }`, "P2DT1H"); +assert.sameValue(`${ hours25.add(oneDay, { relativeTo }) }`, "P2D"); + +// start before skipped hour, end >1 day after", +assert.sameValue(`${ hours25.add(oneDay, { relativeTo: skippedHourDay }) }`, "P2DT2H"); +assert.sameValue(`${ oneDay.add(hours25, { relativeTo: skippedHourDay }) }`, "P2DT1H"); + +// start after skipped hour, end >1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-03-11T00:00[America/Vancouver]"); +assert.sameValue(`${ hours25.negated().add(oneDay.negated(), { relativeTo }) }`, "-P2DT2H"); +assert.sameValue(`${ oneDay.negated().add(hours25.negated(), { relativeTo }) }`, "-P2DT1H"); + +// start before skipped hour, end <1 day after", +assert.sameValue(`${ hours12.add(oneDay, { relativeTo: skippedHourDay }) }`, "P1DT13H"); +assert.sameValue(`${ oneDay.add(hours12, { relativeTo: skippedHourDay }) }`, "P1DT12H"); + +// start after skipped hour, end <1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-03-10T12:00[America/Vancouver]"); +assert.sameValue(`${ hours12.negated().add(oneDay.negated(), { relativeTo }) }`, "-P1DT13H"); +assert.sameValue(`${ oneDay.negated().add(hours12.negated(), { relativeTo }) }`, "-P1DT12H"); + +// start before repeated hour, end >1 day after", +assert.sameValue(`${ hours25.add(oneDay, { relativeTo: repeatedHourDay }) }`, "P2D"); +assert.sameValue(`${ oneDay.add(hours25, { relativeTo: repeatedHourDay }) }`, "P2DT1H"); + +// start after repeated hour, end >1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-11-04T00:00[America/Vancouver]"); +assert.sameValue(`${ hours25.negated().add(oneDay.negated(), { relativeTo }) }`, "-P2D"); +assert.sameValue(`${ oneDay.negated().add(hours25.negated(), { relativeTo }) }`, "-P2DT1H"); + +// start before repeated hour, end <1 day after", +assert.sameValue(`${ hours12.add(oneDay, { relativeTo: repeatedHourDay }) }`, "P1DT11H"); +assert.sameValue(`${ oneDay.add(hours12, { relativeTo: repeatedHourDay }) }`, "P1DT12H"); + +// start after repeated hour, end <1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-11-03T12:00[America/Vancouver]"); +assert.sameValue(`${ hours12.negated().add(oneDay.negated(), { relativeTo }) }`, "-P1DT11H"); +assert.sameValue(`${ oneDay.negated().add(hours12.negated(), { relativeTo }) }`, "-P1DT12H"); + +// Samoa skipped 24 hours", +var relativeTo = Temporal.ZonedDateTime.from("2011-12-29T12:00-10:00[Pacific/Apia]"); +assert.sameValue(`${ hours25.add(oneDay, { relativeTo }) }`, "P3DT1H"); +assert.sameValue(`${ oneDay.add(hours25, { relativeTo }) }`, "P3DT1H"); + +// casts relativeTo to ZonedDateTime if possible +assert.sameValue(`${ oneDay.add(hours24, { relativeTo: "2019-11-02T00:00[America/Vancouver]" }) }`, "P1DT24H"); +assert.sameValue(`${ oneDay.add(hours24, { + relativeTo: { + year: 2019, + month: 11, + day: 2, + timeZone: "America/Vancouver" + } +}) }`, "P1DT24H"); + +// casts relativeTo to PlainDate if possible +assert.sameValue(`${ oneDay.add(hours24, { relativeTo: "2019-11-02" }) }`, "P2D"); +assert.sameValue(`${ oneDay.add(hours24, { + relativeTo: { + year: 2019, + month: 11, + day: 2 + } +}) }`, "P2D"); + +// throws on wrong offset for ZonedDateTime relativeTo string +assert.throws(RangeError, () => oneDay.add(hours24, { relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]" })); + +// does not throw on HH:MM rounded offset for ZonedDateTime relativeTo string +assert.sameValue(`${ oneDay.add(hours24, { relativeTo: "1971-01-01T00:00-00:45[Africa/Monrovia]" }) }`, "P2D"); + +// throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag +assert.throws(RangeError, () => oneDay.add(hours24, { + relativeTo: { + year: 1971, + month: 1, + day: 1, + offset: "-00:45", + timeZone: "Africa/Monrovia" + } +})); + +// at least the required properties must be present in relativeTo +assert.throws(TypeError, () => oneDay.add(hours24, { + relativeTo: { + month: 11, + day: 3 + } +})); +assert.throws(TypeError, () => oneDay.add(hours24, { + relativeTo: { + year: 2019, + month: 11 + } +})); +assert.throws(TypeError, () => oneDay.add(hours24, { + relativeTo: { + year: 2019, + day: 3 + } +})); diff --git a/test/staging/Temporal/Duration/old/compare-no-precision-loss.js b/test/staging/Temporal/Duration/old/compare-no-precision-loss.js new file mode 100644 index 0000000000..8cab5ade20 --- /dev/null +++ b/test/staging/Temporal/Duration/old/compare-no-precision-loss.js @@ -0,0 +1,13 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-duration-objects +description: Temporal.Duration.compare() does not lose precision when totaling everything down to nanoseconds +features: [Temporal] +---*/ + +assert.notSameValue(Temporal.Duration.compare({ days: 200 }, { + days: 200, + nanoseconds: 1 +}), 0); diff --git a/test/staging/Temporal/Duration/old/limits.js b/test/staging/Temporal/Duration/old/limits.js new file mode 100644 index 0000000000..eb24e8316b --- /dev/null +++ b/test/staging/Temporal/Duration/old/limits.js @@ -0,0 +1,92 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-duration-objects +description: min/max values +features: [Temporal] +---*/ + +var units = [ + "years", + "months", + "weeks", + "days", + "hours", + "minutes", + "seconds", + "milliseconds", + "microseconds", + "nanoseconds" +]; + +// minimum is zero +assert.sameValue(`${ new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, 0) }`, "PT0S"); +units.forEach(unit => assert.sameValue(`${ Temporal.Duration.from({ [unit]: 0 }) }`, "PT0S")); +[ + "P0Y", + "P0M", + "P0W", + "P0D", + "PT0H", + "PT0M", + "PT0S" +].forEach(str => assert.sameValue(`${ Temporal.Duration.from(str) }`, "PT0S")); + +// unrepresentable number is not allowed +units.forEach((unit, ix) => { + assert.throws(RangeError, () => new Temporal.Duration(...Array(ix).fill(0), 1e+400)); + assert.throws(RangeError, () => Temporal.Duration.from({ [unit]: 1e+400 })); +}); +var manyNines = "9".repeat(309); +[ + `P${ manyNines }Y`, + `P${ manyNines }M`, + `P${ manyNines }W`, + `P${ manyNines }D`, + `PT${ manyNines }H`, + `PT${ manyNines }M`, + `PT${ manyNines }S` +].forEach(str => assert.throws(RangeError, () => Temporal.Duration.from(str))); + +// max safe integer is allowed +[ + "P9007199254740991Y", + "P9007199254740991M", + "P9007199254740991W", + "P9007199254740991D", + "PT9007199254740991H", + "PT9007199254740991M", + "PT9007199254740991S", + "PT9007199254740.991S", + "PT9007199254.740991S", + "PT9007199.254740991S" +].forEach((str, ix) => { + assert.sameValue(`${ new Temporal.Duration(...Array(ix).fill(0), Number.MAX_SAFE_INTEGER) }`, str); + assert.sameValue(`${ Temporal.Duration.from(str) }`, str); +}); + +// larger integers are allowed but may lose precision +function test(ix, prefix, suffix, infix = "") { + function doAsserts(duration) { + var str = duration.toString(); + assert.sameValue(str.slice(0, prefix.length + 10), `${ prefix }1000000000`); + assert(str.includes(infix)); + assert.sameValue(str.slice(-1), suffix); + assert.sameValue(str.length, prefix.length + suffix.length + infix.length + 27); + } + doAsserts(new Temporal.Duration(...Array(ix).fill(0), 1e+26, ...Array(9 - ix).fill(0))); + doAsserts(Temporal.Duration.from({ [units[ix]]: 1e+26 })); + if (!infix) + doAsserts(Temporal.Duration.from(`${ prefix }100000000000000000000000000${ suffix }`)); +} +test(0, "P", "Y"); +test(1, "P", "M"); +test(2, "P", "W"); +test(3, "P", "D"); +test(4, "PT", "H"); +test(5, "PT", "M"); +test(6, "PT", "S"); +test(7, "PT", "S", "."); +test(8, "PT", "S", "."); +test(9, "PT", "S", "."); diff --git a/test/staging/Temporal/Duration/old/round.js b/test/staging/Temporal/Duration/old/round.js new file mode 100644 index 0000000000..16521cc62a --- /dev/null +++ b/test/staging/Temporal/Duration/old/round.js @@ -0,0 +1,902 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-duration-objects +description: Temporal.Duration.prototype.round() works as expected +features: [Temporal] +---*/ + +var d = new Temporal.Duration(5, 5, 5, 5, 5, 5, 5, 5, 5, 5); +var d2 = new Temporal.Duration(0, 0, 0, 5, 5, 5, 5, 5, 5, 5); +var relativeTo = Temporal.PlainDate.from("2020-01-01"); + +// succeeds with largestUnit: 'auto' +assert.sameValue(`${ Temporal.Duration.from({ hours: 25 }).round({ largestUnit: "auto" }) }`, "PT25H"); +var hours25 = new Temporal.Duration(0, 0, 0, 0, 25); + +// days are 24 hours if relativeTo not given +assert.sameValue(`${ hours25.round({ largestUnit: "days" }) }`, "P1DT1H"); + +// days are 24 hours if relativeTo is PlainDate +var relativeTo = Temporal.PlainDate.from("2017-01-01"); +assert.sameValue(`${ hours25.round({ + largestUnit: "days", + relativeTo +}) }`, "P1DT1H"); + +// days are 24 hours if relativeTo is ZonedDateTime, and duration encompasses no DST change +var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[America/Montevideo]"); +assert.sameValue(`${ hours25.round({ + largestUnit: "days", + relativeTo +}) }`, "P1DT1H"); +var skippedHourDay = Temporal.ZonedDateTime.from("2019-03-10T00:00[America/Vancouver]"); +var repeatedHourDay = Temporal.ZonedDateTime.from("2019-11-03T00:00[America/Vancouver]"); +var inRepeatedHour = Temporal.ZonedDateTime.from("2019-11-03T01:00-07:00[America/Vancouver]"); +var oneDay = new Temporal.Duration(0, 0, 0, 1); +var hours12 = new Temporal.Duration(0, 0, 0, 0, 12); + +// relativeTo affects days if ZonedDateTime, and duration encompasses DST change" + +// start inside repeated hour, end after", +assert.sameValue(`${ hours25.round({ + largestUnit: "days", + relativeTo: inRepeatedHour +}) }`, "P1D"); +assert.sameValue(`${ oneDay.round({ + largestUnit: "hours", + relativeTo: inRepeatedHour +}) }`, "PT25H"); + +// start after repeated hour, end inside (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-11-04T01:00[America/Vancouver]"); +assert.sameValue(`${ hours25.negated().round({ + largestUnit: "days", + relativeTo +}) }`, "-P1D"); +assert.sameValue(`${ oneDay.negated().round({ + largestUnit: "hours", + relativeTo +}) }`, "-PT25H"); + +// start inside repeated hour, end in skipped hour", +assert.sameValue(`${ Temporal.Duration.from({ + days: 126, + hours: 1 +}).round({ + largestUnit: "days", + relativeTo: inRepeatedHour +}) }`, "P126DT1H"); +assert.sameValue(`${ Temporal.Duration.from({ + days: 126, + hours: 1 +}).round({ + largestUnit: "hours", + relativeTo: inRepeatedHour +}) }`, "PT3026H"); + +// start in normal hour, end in skipped hour", +var relativeTo = Temporal.ZonedDateTime.from("2019-03-09T02:30[America/Vancouver]"); +assert.sameValue(`${ hours25.round({ + largestUnit: "days", + relativeTo +}) }`, "P1DT1H"); +assert.sameValue(`${ oneDay.round({ + largestUnit: "hours", + relativeTo +}) }`, "PT24H"); + +// start before skipped hour, end >1 day after", +assert.sameValue(`${ hours25.round({ + largestUnit: "days", + relativeTo: skippedHourDay +}) }`, "P1DT2H"); +assert.sameValue(`${ oneDay.round({ + largestUnit: "hours", + relativeTo: skippedHourDay +}) }`, "PT23H"); + +// start after skipped hour, end >1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-03-11T00:00[America/Vancouver]"); +assert.sameValue(`${ hours25.negated().round({ + largestUnit: "days", + relativeTo +}) }`, "-P1DT2H"); +assert.sameValue(`${ oneDay.negated().round({ + largestUnit: "hours", + relativeTo +}) }`, "-PT23H"); + +// start before skipped hour, end <1 day after", +assert.sameValue(`${ hours12.round({ + largestUnit: "days", + relativeTo: skippedHourDay +}) }`, "PT12H"); + +// start after skipped hour, end <1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-03-10T12:00[America/Vancouver]"); +assert.sameValue(`${ hours12.negated().round({ + largestUnit: "days", + relativeTo +}) }`, "-PT12H"); + +// start before repeated hour, end >1 day after", +assert.sameValue(`${ hours25.round({ + largestUnit: "days", + relativeTo: repeatedHourDay +}) }`, "P1D"); +assert.sameValue(`${ oneDay.round({ + largestUnit: "hours", + relativeTo: repeatedHourDay +}) }`, "PT25H"); + +// start after repeated hour, end >1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-11-04T00:00[America/Vancouver]"); +assert.sameValue(`${ hours25.negated().round({ + largestUnit: "days", + relativeTo +}) }`, "-P1D"); +assert.sameValue(`${ oneDay.negated().round({ + largestUnit: "hours", + relativeTo +}) }`, "-PT25H"); + +// start before repeated hour, end <1 day after", +assert.sameValue(`${ hours12.round({ + largestUnit: "days", + relativeTo: repeatedHourDay +}) }`, "PT12H"); + +// start after repeated hour, end <1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-11-03T12:00[America/Vancouver]"); +assert.sameValue(`${ hours12.negated().round({ + largestUnit: "days", + relativeTo +}) }`, "-PT12H"); + +// Samoa skipped 24 hours", +var relativeTo = Temporal.ZonedDateTime.from("2011-12-29T12:00-10:00[Pacific/Apia]"); +assert.sameValue(`${ hours25.round({ + largestUnit: "days", + relativeTo +}) }`, "P2DT1H"); +assert.sameValue(`${ Temporal.Duration.from({ hours: 48 }).round({ + largestUnit: "days", + relativeTo +}) }`, "P3D"); + +// casts relativeTo to ZonedDateTime if possible +assert.sameValue(`${ hours25.round({ + largestUnit: "days", + relativeTo: "2019-11-03T00:00[America/Vancouver]" +}) }`, "P1D"); +assert.sameValue(`${ hours25.round({ + largestUnit: "days", + relativeTo: { + year: 2019, + month: 11, + day: 3, + timeZone: "America/Vancouver" + } +}) }`, "P1D"); + +// casts relativeTo to PlainDate if possible +assert.sameValue(`${ hours25.round({ + largestUnit: "days", + relativeTo: "2019-11-02" +}) }`, "P1DT1H"); +assert.sameValue(`${ hours25.round({ + largestUnit: "days", + relativeTo: { + year: 2019, + month: 11, + day: 2 + } +}) }`, "P1DT1H"); + +// accepts datetime string equivalents or fields for relativeTo +[ + "2020-01-01", + "2020-01-01T00:00:00.000000000", + 20200101n, + { + year: 2020, + month: 1, + day: 1 + } +].forEach(relativeTo => { + assert.sameValue(`${ d.round({ + smallestUnit: "seconds", + relativeTo + }) }`, "P5Y5M5W5DT5H5M5S"); +}); + +// throws on wrong offset for ZonedDateTime relativeTo string +assert.throws(RangeError, () => d.round({ + smallestUnit: "seconds", + relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]" +})); + +// does not throw on HH:MM rounded offset for ZonedDateTime relativeTo string +assert.sameValue(`${ d.round({ + smallestUnit: "seconds", + relativeTo: "1971-01-01T00:00-00:45[Africa/Monrovia]" +}) }`, "P5Y5M5W5DT5H5M5S"); + +// throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag +assert.throws(RangeError, () => d.round({ + smallestUnit: "seconds", + relativeTo: { + year: 1971, + month: 1, + day: 1, + offset: "-00:45", + timeZone: "Africa/Monrovia" + } +})); + +// relativeTo object must contain at least the required correctly-spelled properties +assert.throws(TypeError, () => hours25.round({ + largestUnit: "days", + relativeTo: { + month: 11, + day: 3 + } +})); +assert.throws(TypeError, () => hours25.round({ + largestUnit: "days", + relativeTo: { + year: 2019, + month: 11 + } +})); +assert.throws(TypeError, () => hours25.round({ + largestUnit: "days", + relativeTo: { + year: 2019, + day: 3 + } +})); + +// incorrectly-spelled properties are ignored in relativeTo +var oneMonth = Temporal.Duration.from({ months: 1 }); +assert.sameValue(`${ oneMonth.round({ + largestUnit: "days", + relativeTo: { + year: 2020, + month: 1, + day: 1, + months: 2 + } +}) }`, "P31D"); + +// throws if neither one of largestUnit or smallestUnit is given +var hoursOnly = new Temporal.Duration(0, 0, 0, 0, 1); +[ + {}, + () => { + }, + { roundingMode: "ceil" } +].forEach(roundTo => { + assert.throws(RangeError, () => d.round(roundTo)); + assert.throws(RangeError, () => hoursOnly.round(roundTo)); +}); + +// relativeTo not required to round non-calendar units in durations w/o calendar units (string param) +assert.sameValue(`${ d2.round("days") }`, "P5D"); +assert.sameValue(`${ d2.round("hours") }`, "P5DT5H"); +assert.sameValue(`${ d2.round("minutes") }`, "P5DT5H5M"); +assert.sameValue(`${ d2.round("seconds") }`, "P5DT5H5M5S"); +assert.sameValue(`${ d2.round("milliseconds") }`, "P5DT5H5M5.005S"); +assert.sameValue(`${ d2.round("microseconds") }`, "P5DT5H5M5.005005S"); +assert.sameValue(`${ d2.round("nanoseconds") }`, "P5DT5H5M5.005005005S"); + +// relativeTo is required to round calendar units even in durations w/o calendar units (string param) +assert.throws(RangeError, () => d2.round("years")); +assert.throws(RangeError, () => d2.round("months")); +assert.throws(RangeError, () => d2.round("weeks")); + +// relativeTo not required to round non-calendar units in durations w/o calendar units (object param) +assert.sameValue(`${ d2.round({ smallestUnit: "days" }) }`, "P5D"); +assert.sameValue(`${ d2.round({ smallestUnit: "hours" }) }`, "P5DT5H"); +assert.sameValue(`${ d2.round({ smallestUnit: "minutes" }) }`, "P5DT5H5M"); +assert.sameValue(`${ d2.round({ smallestUnit: "seconds" }) }`, "P5DT5H5M5S"); +assert.sameValue(`${ d2.round({ smallestUnit: "milliseconds" }) }`, "P5DT5H5M5.005S"); +assert.sameValue(`${ d2.round({ smallestUnit: "microseconds" }) }`, "P5DT5H5M5.005005S"); +assert.sameValue(`${ d2.round({ smallestUnit: "nanoseconds" }) }`, "P5DT5H5M5.005005005S"); + +// relativeTo is required to round calendar units even in durations w/o calendar units (object param) +assert.throws(RangeError, () => d2.round({ smallestUnit: "years" })); +assert.throws(RangeError, () => d2.round({ smallestUnit: "months" })); +assert.throws(RangeError, () => d2.round({ smallestUnit: "weeks" })); + +// relativeTo is required for rounding durations with calendar units +assert.throws(RangeError, () => d.round({ largestUnit: "years" })); +assert.throws(RangeError, () => d.round({ largestUnit: "months" })); +assert.throws(RangeError, () => d.round({ largestUnit: "weeks" })); +assert.throws(RangeError, () => d.round({ largestUnit: "days" })); +assert.throws(RangeError, () => d.round({ largestUnit: "hours" })); +assert.throws(RangeError, () => d.round({ largestUnit: "minutes" })); +assert.throws(RangeError, () => d.round({ largestUnit: "seconds" })); +assert.throws(RangeError, () => d.round({ largestUnit: "milliseconds" })); +assert.throws(RangeError, () => d.round({ largestUnit: "microseconds" })); +assert.throws(RangeError, () => d.round({ largestUnit: "nanoseconds" })); + +// durations do not balance beyond their current largest unit by default +var relativeTo = Temporal.PlainDate.from("2020-01-01"); +var fortyDays = Temporal.Duration.from({ days: 40 }); +assert.sameValue(`${ fortyDays.round({ smallestUnit: "seconds" }) }`, "P40D"); +var roundAndBalanceResults = { + years: { + years: "P6Y", + months: "P5Y6M", + weeks: "P5Y5M6W", + days: "P5Y5M5W5D", + hours: "P5Y5M5W5DT5H", + minutes: "P5Y5M5W5DT5H5M", + seconds: "P5Y5M5W5DT5H5M5S", + milliseconds: "P5Y5M5W5DT5H5M5.005S", + microseconds: "P5Y5M5W5DT5H5M5.005005S", + nanoseconds: "P5Y5M5W5DT5H5M5.005005005S" + }, + months: { + months: "P66M", + weeks: "P65M6W", + days: "P65M5W5D", + hours: "P65M5W5DT5H", + minutes: "P65M5W5DT5H5M", + seconds: "P65M5W5DT5H5M5S", + milliseconds: "P65M5W5DT5H5M5.005S", + microseconds: "P65M5W5DT5H5M5.005005S", + nanoseconds: "P65M5W5DT5H5M5.005005005S" + }, + weeks: { + weeks: "P288W", + days: "P288W2D", + hours: "P288W2DT5H", + minutes: "P288W2DT5H5M", + seconds: "P288W2DT5H5M5S", + milliseconds: "P288W2DT5H5M5.005S", + microseconds: "P288W2DT5H5M5.005005S", + nanoseconds: "P288W2DT5H5M5.005005005S" + }, + days: { + days: "P2018D", + hours: "P2018DT5H", + minutes: "P2018DT5H5M", + seconds: "P2018DT5H5M5S", + milliseconds: "P2018DT5H5M5.005S", + microseconds: "P2018DT5H5M5.005005S", + nanoseconds: "P2018DT5H5M5.005005005S" + }, + hours: { + hours: "PT48437H", + minutes: "PT48437H5M", + seconds: "PT48437H5M5S", + milliseconds: "PT48437H5M5.005S", + microseconds: "PT48437H5M5.005005S", + nanoseconds: "PT48437H5M5.005005005S" + }, + minutes: { + minutes: "PT2906225M", + seconds: "PT2906225M5S", + milliseconds: "PT2906225M5.005S", + microseconds: "PT2906225M5.005005S", + nanoseconds: "PT2906225M5.005005005S" + }, + seconds: { + seconds: "PT174373505S", + milliseconds: "PT174373505.005S", + microseconds: "PT174373505.005005S", + nanoseconds: "PT174373505.005005005S" + }, + milliseconds: { + milliseconds: "PT174373505.005S", + microseconds: "PT174373505.005005S", + nanoseconds: "PT174373505.005005005S" + } +}; +for (var [largestUnit, entry] of Object.entries(roundAndBalanceResults)) { + for (var [smallestUnit, expected] of Object.entries(entry)) { + assert.sameValue(`${ d.round({ + largestUnit, + smallestUnit, + relativeTo + }) }`, expected); + } +} +var balanceLosePrecisionResults = { + microseconds: [ + "microseconds", + "nanoseconds" + ], + nanoseconds: ["nanoseconds"] +}; + +// Round may lose precision below ms +for (var [largestUnit, entry] of Object.entries(balanceLosePrecisionResults)) { + for (var smallestUnit of entry) { + assert(`${ d.round({ + largestUnit, + smallestUnit, + relativeTo + }) }`.startsWith("PT174373505.005")); + } +} +var roundingModeResults = { + halfExpand: [ + "P6Y", + "-P6Y" + ], + ceil: [ + "P6Y", + "-P5Y" + ], + floor: [ + "P5Y", + "-P6Y" + ], + trunc: [ + "P5Y", + "-P5Y" + ] +}; +for (var [roundingMode, [posResult, negResult]] of Object.entries(roundingModeResults)) { + assert.sameValue(`${ d.round({ + smallestUnit: "years", + relativeTo, + roundingMode + }) }`, posResult); + assert.sameValue(`${ d.negated().round({ + smallestUnit: "years", + relativeTo, + roundingMode + }) }`, negResult); +} + +// halfExpand is the default +assert.sameValue(`${ d.round({ + smallestUnit: "years", + relativeTo +}) }`, "P6Y"); +assert.sameValue(`${ d.negated().round({ + smallestUnit: "years", + relativeTo +}) }`, "-P6Y"); + +// balances up differently depending on relativeTo +var fortyDays = Temporal.Duration.from({ days: 40 }); +assert.sameValue(`${ fortyDays.round({ + largestUnit: "years", + relativeTo: "2020-01-01" +}) }`, "P1M9D"); +assert.sameValue(`${ fortyDays.round({ + largestUnit: "years", + relativeTo: "2020-02-01" +}) }`, "P1M11D"); +assert.sameValue(`${ fortyDays.round({ + largestUnit: "years", + relativeTo: "2020-03-01" +}) }`, "P1M9D"); +assert.sameValue(`${ fortyDays.round({ + largestUnit: "years", + relativeTo: "2020-04-01" +}) }`, "P1M10D"); +var minusForty = Temporal.Duration.from({ days: -40 }); +assert.sameValue(`${ minusForty.round({ + largestUnit: "years", + relativeTo: "2020-02-01" +}) }`, "-P1M9D"); +assert.sameValue(`${ minusForty.round({ + largestUnit: "years", + relativeTo: "2020-01-01" +}) }`, "-P1M9D"); +assert.sameValue(`${ minusForty.round({ + largestUnit: "years", + relativeTo: "2020-03-01" +}) }`, "-P1M11D"); +assert.sameValue(`${ minusForty.round({ + largestUnit: "years", + relativeTo: "2020-04-01" +}) }`, "-P1M9D"); + +// balances up to the next unit after rounding +var almostWeek = Temporal.Duration.from({ + days: 6, + hours: 20 +}); +assert.sameValue(`${ almostWeek.round({ + largestUnit: "weeks", + smallestUnit: "days", + relativeTo: "2020-01-01" +}) }`, "P1W"); + +// balances days up to both years and months +var twoYears = Temporal.Duration.from({ + months: 11, + days: 396 +}); +assert.sameValue(`${ twoYears.round({ + largestUnit: "years", + relativeTo: "2017-01-01" +}) }`, "P2Y"); + +// does not balance up to weeks if largestUnit is larger than weeks +var monthAlmostWeek = Temporal.Duration.from({ + months: 1, + days: 6, + hours: 20 +}); +assert.sameValue(`${ monthAlmostWeek.round({ + smallestUnit: "days", + relativeTo: "2020-01-01" +}) }`, "P1M7D"); + +// balances down differently depending on relativeTo +var oneYear = Temporal.Duration.from({ years: 1 }); +assert.sameValue(`${ oneYear.round({ + largestUnit: "days", + relativeTo: "2019-01-01" +}) }`, "P365D"); +assert.sameValue(`${ oneYear.round({ + largestUnit: "days", + relativeTo: "2019-07-01" +}) }`, "P366D"); +var minusYear = Temporal.Duration.from({ years: -1 }); +assert.sameValue(`${ minusYear.round({ + largestUnit: "days", + relativeTo: "2020-01-01" +}) }`, "-P365D"); +assert.sameValue(`${ minusYear.round({ + largestUnit: "days", + relativeTo: "2020-07-01" +}) }`, "-P366D"); + +// rounds to an increment of hours +assert.sameValue(`${ d.round({ + smallestUnit: "hours", + roundingIncrement: 3, + relativeTo +}) }`, "P5Y5M5W5DT6H"); + +// rounds to an increment of minutes +assert.sameValue(`${ d.round({ + smallestUnit: "minutes", + roundingIncrement: 30, + relativeTo +}) }`, "P5Y5M5W5DT5H"); + +// rounds to an increment of seconds +assert.sameValue(`${ d.round({ + smallestUnit: "seconds", + roundingIncrement: 15, + relativeTo +}) }`, "P5Y5M5W5DT5H5M"); + +// rounds to an increment of milliseconds +assert.sameValue(`${ d.round({ + smallestUnit: "milliseconds", + roundingIncrement: 10, + relativeTo +}) }`, "P5Y5M5W5DT5H5M5.01S"); + +// rounds to an increment of microseconds +assert.sameValue(`${ d.round({ + smallestUnit: "microseconds", + roundingIncrement: 10, + relativeTo +}) }`, "P5Y5M5W5DT5H5M5.00501S"); + +// rounds to an increment of nanoseconds +assert.sameValue(`${ d.round({ + smallestUnit: "nanoseconds", + roundingIncrement: 10, + relativeTo +}) }`, "P5Y5M5W5DT5H5M5.00500501S"); + +// valid hour increments divide into 24 +[ + 1, + 2, + 3, + 4, + 6, + 8, + 12 +].forEach(roundingIncrement => { + var options = { + smallestUnit: "hours", + roundingIncrement, + relativeTo + }; + assert(d.round(options) instanceof Temporal.Duration); +}); +[ + "minutes", + "seconds" +].forEach(smallestUnit => { + // valid minutes/seconds increments divide into 60 + [ + 1, + 2, + 3, + 4, + 5, + 6, + 10, + 12, + 15, + 20, + 30 + ].forEach(roundingIncrement => { + var roundTo = { + smallestUnit, + roundingIncrement, + relativeTo + }; + assert(d.round(roundTo) instanceof Temporal.Duration); + }); + }); +[ + "milliseconds", + "microseconds", + "nanoseconds" +].forEach(smallestUnit => { + // valid milliseconds/microseconds/nanoseconds increments divide into 1000 + [ + 1, + 2, + 4, + 5, + 8, + 10, + 20, + 25, + 40, + 50, + 100, + 125, + 200, + 250, + 500 + ].forEach(roundingIncrement => { + var roundTo = { + smallestUnit, + roundingIncrement, + relativeTo + }; + assert(d.round(roundTo) instanceof Temporal.Duration); + }); + }); + +// throws on increments that do not divide evenly into the next highest +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "hours", + roundingIncrement: 11 +})); +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "minutes", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "seconds", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "milliseconds", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "microseconds", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "nanoseconds", + roundingIncrement: 29 +})); + +// throws on increments that are equal to the next highest +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "hours", + roundingIncrement: 24 +})); +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "minutes", + roundingIncrement: 60 +})); +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "seconds", + roundingIncrement: 60 +})); +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "milliseconds", + roundingIncrement: 1000 +})); +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "microseconds", + roundingIncrement: 1000 +})); +assert.throws(RangeError, () => d.round({ + relativeTo, + smallestUnit: "nanoseconds", + roundingIncrement: 1000 +})); + +// accepts singular units +assert.sameValue(`${ d.round({ + largestUnit: "year", + relativeTo +}) }`, `${ d.round({ + largestUnit: "years", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + smallestUnit: "year", + relativeTo +}) }`, `${ d.round({ + smallestUnit: "years", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + largestUnit: "month", + relativeTo +}) }`, `${ d.round({ + largestUnit: "months", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + smallestUnit: "month", + relativeTo +}) }`, `${ d.round({ + smallestUnit: "months", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + largestUnit: "day", + relativeTo +}) }`, `${ d.round({ + largestUnit: "days", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + smallestUnit: "day", + relativeTo +}) }`, `${ d.round({ + smallestUnit: "days", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + largestUnit: "hour", + relativeTo +}) }`, `${ d.round({ + largestUnit: "hours", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + smallestUnit: "hour", + relativeTo +}) }`, `${ d.round({ + smallestUnit: "hours", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + largestUnit: "minute", + relativeTo +}) }`, `${ d.round({ + largestUnit: "minutes", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + smallestUnit: "minute", + relativeTo +}) }`, `${ d.round({ + smallestUnit: "minutes", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + largestUnit: "second", + relativeTo +}) }`, `${ d.round({ + largestUnit: "seconds", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + smallestUnit: "second", + relativeTo +}) }`, `${ d.round({ + smallestUnit: "seconds", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + largestUnit: "millisecond", + relativeTo +}) }`, `${ d.round({ + largestUnit: "milliseconds", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + smallestUnit: "millisecond", + relativeTo +}) }`, `${ d.round({ + smallestUnit: "milliseconds", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + largestUnit: "microsecond", + relativeTo +}) }`, `${ d.round({ + largestUnit: "microseconds", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + smallestUnit: "microsecond", + relativeTo +}) }`, `${ d.round({ + smallestUnit: "microseconds", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + largestUnit: "nanosecond", + relativeTo +}) }`, `${ d.round({ + largestUnit: "nanoseconds", + relativeTo +}) }`); +assert.sameValue(`${ d.round({ + smallestUnit: "nanosecond", + relativeTo +}) }`, `${ d.round({ + smallestUnit: "nanoseconds", + relativeTo +}) }`); + +// counts the correct number of days when rounding relative to a date +var days = Temporal.Duration.from({ days: 45 }); +assert.sameValue(`${ days.round({ + relativeTo: "2019-01-01", + smallestUnit: "months" +}) }`, "P2M"); +assert.sameValue(`${ days.negated().round({ + relativeTo: "2019-02-15", + smallestUnit: "months" +}) }`, "-P1M"); +var yearAndHalf = Temporal.Duration.from({ + days: 547, + hours: 12 +}); +assert.sameValue(`${ yearAndHalf.round({ + relativeTo: "2018-01-01", + smallestUnit: "years" +}) }`, "P2Y"); +assert.sameValue(`${ yearAndHalf.round({ + relativeTo: "2018-07-01", + smallestUnit: "years" +}) }`, "P1Y"); +assert.sameValue(`${ yearAndHalf.round({ + relativeTo: "2019-01-01", + smallestUnit: "years" +}) }`, "P1Y"); +assert.sameValue(`${ yearAndHalf.round({ + relativeTo: "2019-07-01", + smallestUnit: "years" +}) }`, "P1Y"); +assert.sameValue(`${ yearAndHalf.round({ + relativeTo: "2020-01-01", + smallestUnit: "years" +}) }`, "P1Y"); +assert.sameValue(`${ yearAndHalf.round({ + relativeTo: "2020-07-01", + smallestUnit: "years" +}) }`, "P2Y"); diff --git a/test/staging/Temporal/Duration/old/subtract.js b/test/staging/Temporal/Duration/old/subtract.js new file mode 100644 index 0000000000..d9e0b81b6f --- /dev/null +++ b/test/staging/Temporal/Duration/old/subtract.js @@ -0,0 +1,123 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-duration-objects +description: Temporal.Duration.prototype.subtract() works as expected +features: [Temporal] +---*/ + +var oneDay = new Temporal.Duration(0, 0, 0, 1); +var hours24 = new Temporal.Duration(0, 0, 0, 0, 24); + +// relativeTo does not affect days if PlainDate +var relativeTo = Temporal.PlainDate.from("2017-01-01"); +assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo }) }`, "PT0S"); + +// relativeTo does not affect days if ZonedDateTime, and duration encompasses no DST change +var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[America/Montevideo]"); +assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo }) }`, "PT0S"); +var skippedHourDay = Temporal.ZonedDateTime.from("2019-03-10T00:00[America/Vancouver]"); +var repeatedHourDay = Temporal.ZonedDateTime.from("2019-11-03T00:00[America/Vancouver]"); +var inRepeatedHour = Temporal.ZonedDateTime.from("2019-11-03T01:00-07:00[America/Vancouver]"); +var twoDays = new Temporal.Duration(0, 0, 0, 2); +var threeDays = new Temporal.Duration(0, 0, 0, 3); +// relativeTo affects days if ZonedDateTime, and duration encompasses DST change + +// start inside repeated hour, end after" +assert.sameValue(`${ hours24.subtract(oneDay, { relativeTo: inRepeatedHour }) }`, "-PT1H"); +assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo: inRepeatedHour }) }`, "PT1H"); + +// start inside repeated hour, end in skipped hour +assert.sameValue(`${ Temporal.Duration.from({ + days: 127, + hours: 1 +}).subtract(oneDay, { relativeTo: inRepeatedHour }) }`, "P126DT1H"); +assert.sameValue(`${ Temporal.Duration.from({ + days: 127, + hours: 1 +}).subtract(hours24, { relativeTo: inRepeatedHour }) }`, "P126D"); + +// start in normal hour, end in skipped hour +var relativeTo = Temporal.ZonedDateTime.from("2019-03-09T02:30[America/Vancouver]"); +assert.sameValue(`${ hours24.subtract(oneDay, { relativeTo }) }`, "PT1H"); +assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo }) }`, "PT0S"); + +// start before skipped hour, end >1 day after +assert.sameValue(`${ threeDays.subtract(hours24, { relativeTo: skippedHourDay }) }`, "P2D"); +assert.sameValue(`${ hours24.subtract(threeDays, { relativeTo: skippedHourDay }) }`, "-P1DT23H"); + +// start before skipped hour, end <1 day after +assert.sameValue(`${ twoDays.subtract(hours24, { relativeTo: skippedHourDay }) }`, "P1D"); +assert.sameValue(`${ hours24.subtract(twoDays, { relativeTo: skippedHourDay }) }`, "-PT23H"); + +// start before repeated hour, end >1 day after +assert.sameValue(`${ threeDays.subtract(hours24, { relativeTo: repeatedHourDay }) }`, "P2D"); +assert.sameValue(`${ hours24.subtract(threeDays, { relativeTo: repeatedHourDay }) }`, "-P2DT1H"); + +// start before repeated hour, end <1 day after +assert.sameValue(`${ twoDays.subtract(hours24, { relativeTo: repeatedHourDay }) }`, "P1D"); +assert.sameValue(`${ hours24.subtract(twoDays, { relativeTo: repeatedHourDay }) }`, "-P1DT1H"); + +// Samoa skipped 24 hours +var relativeTo = Temporal.ZonedDateTime.from("2011-12-29T12:00-10:00[Pacific/Apia]"); +assert.sameValue(`${ twoDays.subtract(Temporal.Duration.from({ hours: 48 }), { relativeTo }) }`, "-P1D"); +assert.sameValue(`${ Temporal.Duration.from({ hours: 48 }).subtract(twoDays, { relativeTo }) }`, "P2D"); + +// casts relativeTo to ZonedDateTime if possible +assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo: "2019-11-03T00:00[America/Vancouver]" }) }`, "PT1H"); +assert.sameValue(`${ oneDay.subtract(hours24, { + relativeTo: { + year: 2019, + month: 11, + day: 3, + timeZone: "America/Vancouver" + } +}) }`, "PT1H"); + +// casts relativeTo to PlainDate if possible +assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo: "2019-11-02" }) }`, "PT0S"); +assert.sameValue(`${ oneDay.subtract(hours24, { + relativeTo: { + year: 2019, + month: 11, + day: 2 + } +}) }`, "PT0S"); + +// throws on wrong offset for ZonedDateTime relativeTo string +assert.throws(RangeError, () => oneDay.subtract(hours24, { relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]" })); + +// does not throw on HH:MM rounded offset for ZonedDateTime relativeTo string +assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo: "1971-01-01T00:00-00:45[Africa/Monrovia]" }) }`, "PT0S"); + +// throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag +assert.throws(RangeError, () => oneDay.subtract(hours24, { + relativeTo: { + year: 1971, + month: 1, + day: 1, + offset: "-00:45", + timeZone: "Africa/Monrovia" + } +})); + +// at least the required properties must be present in relativeTo +assert.throws(TypeError, () => oneDay.subtract(hours24, { + relativeTo: { + month: 11, + day: 3 + } +})); +assert.throws(TypeError, () => oneDay.subtract(hours24, { + relativeTo: { + year: 2019, + month: 11 + } +})); +assert.throws(TypeError, () => oneDay.subtract(hours24, { + relativeTo: { + year: 2019, + day: 3 + } +})); diff --git a/test/staging/Temporal/Duration/old/toString.js b/test/staging/Temporal/Duration/old/toString.js new file mode 100644 index 0000000000..a08ddf020c --- /dev/null +++ b/test/staging/Temporal/Duration/old/toString.js @@ -0,0 +1,32 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-duration-objects +description: toString() works as expected +features: [Temporal] +---*/ + + +// serializing balance doesn't trip out-of-range +var d = Temporal.Duration.from({ + seconds: Number.MAX_VALUE, + milliseconds: Number.MAX_VALUE +}); +var str = d.toString(); +assert(str.startsWith("PT")); +assert(str.endsWith("S")); + +// serializing balance doesn't lose precision when values are precise +var d = Temporal.Duration.from({ + milliseconds: Number.MAX_SAFE_INTEGER, + microseconds: Number.MAX_SAFE_INTEGER +}); +assert.sameValue(`${ d }`, "PT9016206453995.731991S"); + +// rounding can affect units up to seconds +var d4 = Temporal.Duration.from("P1Y1M1W1DT23H59M59.999999999S"); +assert.sameValue(d4.toString({ + fractionalSecondDigits: 8, + roundingMode: "halfExpand" +}), "P1Y1M1W1DT23H59M60.00000000S"); diff --git a/test/staging/Temporal/Duration/old/total.js b/test/staging/Temporal/Duration/old/total.js new file mode 100644 index 0000000000..e532306503 --- /dev/null +++ b/test/staging/Temporal/Duration/old/total.js @@ -0,0 +1,475 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-duration-objects +description: Temporal.Duration.prototype.total() +features: [Temporal] +---*/ + +var d = new Temporal.Duration(5, 5, 5, 5, 5, 5, 5, 5, 5, 5); +var d2 = new Temporal.Duration(0, 0, 0, 5, 5, 5, 5, 5, 5, 5); +var relativeTo = Temporal.PlainDate.from("2020-01-01"); + +// throws on disallowed or invalid unit (object param) +[ + "era", + "nonsense" +].forEach(unit => { + assert.throws(RangeError, () => d.total({ unit })); +}); + +// throws on disallowed or invalid unit (string param) +[ + "era", + "nonsense" +].forEach(unit => { + assert.throws(RangeError, () => d.total(unit)); +}); + +// does not lose precision for seconds and smaller units +var s = Temporal.Duration.from({ + milliseconds: 2, + microseconds: 31 +}).total({ unit: "seconds" }); +assert.sameValue(s, 0.002031); + +// accepts datetime string equivalents or fields for relativeTo +[ + "2020-01-01", + "2020-01-01T00:00:00.000000000", + 20200101n, + { + year: 2020, + month: 1, + day: 1 + } +].forEach(relativeTo => { + var daysPastJuly1 = 5 * 7 + 5 - 30; + var partialDayNanos = d.hours * 3600000000000 + d.minutes * 60000000000 + d.seconds * 1000000000 + d.milliseconds * 1000000 + d.microseconds * 1000 + d.nanoseconds; + var partialDay = partialDayNanos / (3600000000000 * 24); + var partialMonth = (daysPastJuly1 + partialDay) / 31; + var totalMonths = 5 * 12 + 5 + 1 + partialMonth; + var total = d.total({ + unit: "months", + relativeTo + }); + assert.sameValue(total.toPrecision(15), totalMonths.toPrecision(15)); +}); + +// throws on wrong offset for ZonedDateTime relativeTo string +assert.throws(RangeError, () => d.total({ + unit: "months", + relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]" +})); + +// does not throw on HH:MM rounded offset for ZonedDateTime relativeTo string +var oneMonth = Temporal.Duration.from({ months: 1 }); +assert.sameValue(oneMonth.total({ + unit: "months", + relativeTo: "1971-01-01T00:00-00:45[Africa/Monrovia]" +}), 1); + +// throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag +assert.throws(RangeError, () => d.total({ + unit: "months", + relativeTo: { + year: 1971, + month: 1, + day: 1, + offset: "-00:45", + timeZone: "Africa/Monrovia" + } +})); + +// relativeTo object must contain at least the required correctly-spelled properties +assert.throws(TypeError, () => d.total({ + unit: "months", + relativeTo: {} +})); +assert.throws(TypeError, () => d.total({ + unit: "months", + relativeTo: { + years: 2020, + month: 1, + day: 1 + } +})); + +// incorrectly-spelled properties are ignored in relativeTo +var oneMonth = Temporal.Duration.from({ months: 1 }); +assert.sameValue(oneMonth.total({ + unit: "months", + relativeTo: { + year: 2020, + month: 1, + day: 1, + months: 2 + } +}), 1); + +// throws RangeError if unit property is missing +[ + {}, + () => { + }, + { roundingMode: "ceil" } +].forEach(roundTo => assert.throws(RangeError, () => d.total(roundTo))); + +// relativeTo required to round calendar units even in durations w/o calendar units (object param) +assert.throws(RangeError, () => d2.total({ unit: "years" })); +assert.throws(RangeError, () => d2.total({ unit: "months" })); +assert.throws(RangeError, () => d2.total({ unit: "weeks" })); + +// relativeTo required to round calendar units even in durations w/o calendar units (string param) +assert.throws(RangeError, () => d2.total("years")); +assert.throws(RangeError, () => d2.total("months")); +assert.throws(RangeError, () => d2.total("weeks")); + +// relativeTo is required to round durations with calendar units (object param) +assert.throws(RangeError, () => d.total({ unit: "years" })); +assert.throws(RangeError, () => d.total({ unit: "months" })); +assert.throws(RangeError, () => d.total({ unit: "weeks" })); +assert.throws(RangeError, () => d.total({ unit: "days" })); +assert.throws(RangeError, () => d.total({ unit: "hours" })); +assert.throws(RangeError, () => d.total({ unit: "minutes" })); +assert.throws(RangeError, () => d.total({ unit: "seconds" })); +assert.throws(RangeError, () => d.total({ unit: "milliseconds" })); +assert.throws(RangeError, () => d.total({ unit: "microseconds" })); +assert.throws(RangeError, () => d.total({ unit: "nanoseconds" })); + +// relativeTo is required to round durations with calendar units (string param) +assert.throws(RangeError, () => d.total("years")); +assert.throws(RangeError, () => d.total("months")); +assert.throws(RangeError, () => d.total("weeks")); +assert.throws(RangeError, () => d.total("days")); +assert.throws(RangeError, () => d.total("hours")); +assert.throws(RangeError, () => d.total("minutes")); +assert.throws(RangeError, () => d.total("seconds")); +assert.throws(RangeError, () => d.total("milliseconds")); +assert.throws(RangeError, () => d.total("microseconds")); +assert.throws(RangeError, () => d.total("nanoseconds")); +var d2Nanoseconds = d2.days * 24 * 3600000000000 + d2.hours * 3600000000000 + d2.minutes * 60000000000 + d2.seconds * 1000000000 + d2.milliseconds * 1000000 + d2.microseconds * 1000 + d2.nanoseconds; +var totalD2 = { + days: d2Nanoseconds / (24 * 3600000000000), + hours: d2Nanoseconds / 3600000000000, + minutes: d2Nanoseconds / 60000000000, + seconds: d2Nanoseconds / 1000000000, + milliseconds: d2Nanoseconds / 1000000, + microseconds: d2Nanoseconds / 1000, + nanoseconds: d2Nanoseconds +}; + +// relativeTo not required to round fixed-length units in durations without variable units +assert(Math.abs(d2.total({ unit: "days" }) - totalD2.days) < Number.EPSILON); +assert(Math.abs(d2.total({ unit: "hours" }) - totalD2.hours) < Number.EPSILON); +assert(Math.abs(d2.total({ unit: "minutes" }) - totalD2.minutes) < Number.EPSILON); +assert(Math.abs(d2.total({ unit: "seconds" }) - totalD2.seconds) < Number.EPSILON); +assert(Math.abs(d2.total({ unit: "milliseconds" }) - totalD2.milliseconds) < Number.EPSILON); +assert(Math.abs(d2.total({ unit: "microseconds" }) - totalD2.microseconds) < Number.EPSILON); +assert.sameValue(d2.total({ unit: "nanoseconds" }), totalD2.nanoseconds); + +// relativeTo not required to round fixed-length units in durations without variable units (negative) +var negativeD2 = d2.negated(); +assert(Math.abs(negativeD2.total({ unit: "days" }) - -totalD2.days) < Number.EPSILON); +assert(Math.abs(negativeD2.total({ unit: "hours" }) - -totalD2.hours) < Number.EPSILON); +assert(Math.abs(negativeD2.total({ unit: "minutes" }) - -totalD2.minutes) < Number.EPSILON); +assert(Math.abs(negativeD2.total({ unit: "seconds" }) - -totalD2.seconds) < Number.EPSILON); +assert(Math.abs(negativeD2.total({ unit: "milliseconds" }) - -totalD2.milliseconds) < Number.EPSILON); +assert(Math.abs(negativeD2.total({ unit: "microseconds" }) - -totalD2.microseconds) < Number.EPSILON); +assert.sameValue(negativeD2.total({ unit: "nanoseconds" }), -totalD2.nanoseconds); +var endpoint = relativeTo.toPlainDateTime().add(d); +var options = unit => ({ + largestUnit: unit, + smallestUnit: unit, + roundingMode: "trunc" +}); +var fullYears = 5; +var fullDays = endpoint.since(relativeTo, options("days")).days; +var fullMilliseconds = endpoint.since(relativeTo, options("milliseconds")).milliseconds; +var partialDayMilliseconds = fullMilliseconds - fullDays * 24 * 3600000 + 0.005005; +var fractionalDay = partialDayMilliseconds / (24 * 3600000); +var partialYearDays = fullDays - (fullYears * 365 + 2); +var fractionalYear = partialYearDays / 365 + fractionalDay / 365; +var fractionalMonths = ((endpoint.day - 1) * (24 * 3600000) + partialDayMilliseconds) / (31 * 24 * 3600000); +var totalResults = { + years: fullYears + fractionalYear, + months: 66 + fractionalMonths, + weeks: (fullDays + fractionalDay) / 7, + days: fullDays + fractionalDay, + hours: fullDays * 24 + partialDayMilliseconds / 3600000, + minutes: fullDays * 24 * 60 + partialDayMilliseconds / 60000, + seconds: fullDays * 24 * 60 * 60 + partialDayMilliseconds / 1000, + milliseconds: fullMilliseconds + 0.005005, + microseconds: fullMilliseconds * 1000 + 5.005, + nanoseconds: fullMilliseconds * 1000000 + 5005 +}; +for (var [unit, expected] of Object.entries(totalResults)) { + assert.sameValue(d.total({ + unit, + relativeTo + }).toPrecision(15), expected.toPrecision(15)); +} +for (var unit of [ + "microseconds", + "nanoseconds" + ]) { + assert(d.total({ + unit, + relativeTo + }).toString().startsWith("174373505005")); +} + +// balances differently depending on relativeTo +var fortyDays = Temporal.Duration.from({ days: 40 }); +assert.sameValue(fortyDays.total({ + unit: "months", + relativeTo: "2020-02-01" +}).toPrecision(16), (1 + 11 / 31).toPrecision(16)); +assert.sameValue(fortyDays.total({ + unit: "months", + relativeTo: "2020-01-01" +}).toPrecision(16), (1 + 9 / 29).toPrecision(16)); + +// balances differently depending on relativeTo (negative) +var negativeFortyDays = Temporal.Duration.from({ days: -40 }); +assert.sameValue(negativeFortyDays.total({ + unit: "months", + relativeTo: "2020-03-01" +}).toPrecision(16), (-(1 + 11 / 31)).toPrecision(16)); +assert.sameValue(negativeFortyDays.total({ + unit: "months", + relativeTo: "2020-04-01" +}).toPrecision(16), (-(1 + 9 / 29)).toPrecision(16)); + +var oneDay = new Temporal.Duration(0, 0, 0, 1); +// relativeTo does not affect days if PlainDate +var relativeTo = Temporal.PlainDate.from("2017-01-01"); +assert.sameValue(oneDay.total({ + unit: "hours", + relativeTo +}), 24); + +// relativeTo does not affect days if ZonedDateTime, and duration encompasses no DST change +var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[America/Montevideo]"); +assert.sameValue(oneDay.total({ + unit: "hours", + relativeTo +}), 24); +var skippedHourDay = Temporal.ZonedDateTime.from("2019-03-10T00:00[America/Vancouver]"); +var repeatedHourDay = Temporal.ZonedDateTime.from("2019-11-03T00:00[America/Vancouver]"); +var inRepeatedHour = Temporal.ZonedDateTime.from("2019-11-03T01:00-07:00[America/Vancouver]"); +var hours12 = new Temporal.Duration(0, 0, 0, 0, 12); +var hours25 = new Temporal.Duration(0, 0, 0, 0, 25); + +//relativeTo affects days if ZonedDateTime, and duration encompasses DST change" + +// start inside repeated hour, end after", +assert.sameValue(hours25.total({ + unit: "days", + relativeTo: inRepeatedHour +}), 1); +assert.sameValue(oneDay.total({ + unit: "hours", + relativeTo: inRepeatedHour +}), 25); + +// start after repeated hour, end inside (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-11-04T01:00[America/Vancouver]"); +assert.sameValue(hours25.negated().total({ + unit: "days", + relativeTo +}), -1); +assert.sameValue(oneDay.negated().total({ + unit: "hours", + relativeTo +}), -25); + +// start inside repeated hour, end in skipped hour", +var totalDays = Temporal.Duration.from({ + days: 126, + hours: 1 +}).total({ + unit: "days", + relativeTo: inRepeatedHour +}); +assert(Math.abs(totalDays - (126 + 1 / 23)) < Number.EPSILON); +assert.sameValue(Temporal.Duration.from({ + days: 126, + hours: 1 +}).total({ + unit: "hours", + relativeTo: inRepeatedHour +}), 3026); + +// start in normal hour, end in skipped hour", +var relativeTo = Temporal.ZonedDateTime.from("2019-03-09T02:30[America/Vancouver]"); +var totalDays = hours25.total({ + unit: "days", + relativeTo +}); +assert(Math.abs(totalDays - (1 + 1 / 24)) < Number.EPSILON); +assert.sameValue(oneDay.total({ + unit: "hours", + relativeTo +}), 24); + +// start before skipped hour, end >1 day after", +var totalDays = hours25.total({ + unit: "days", + relativeTo: skippedHourDay +}); +assert(Math.abs(totalDays - (1 + 2 / 24)) < Number.EPSILON); +assert.sameValue(oneDay.total({ + unit: "hours", + relativeTo: skippedHourDay +}), 23); + +// start after skipped hour, end >1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-03-11T00:00[America/Vancouver]"); +var totalDays = hours25.negated().total({ + unit: "days", + relativeTo +}); +assert(Math.abs(totalDays - (-1 - 2 / 24)) < Number.EPSILON); +assert.sameValue(oneDay.negated().total({ + unit: "hours", + relativeTo +}), -23); + +// start before skipped hour, end <1 day after", +var totalDays = hours12.total({ + unit: "days", + relativeTo: skippedHourDay +}); +assert(Math.abs(totalDays - 12 / 23) < Number.EPSILON); + +// start after skipped hour, end <1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-03-10T12:00[America/Vancouver]"); +var totalDays = hours12.negated().total({ + unit: "days", + relativeTo +}); +assert(Math.abs(totalDays - -12 / 23) < Number.EPSILON); + +// start before repeated hour, end >1 day after", +assert.sameValue(hours25.total({ + unit: "days", + relativeTo: repeatedHourDay +}), 1); +assert.sameValue(oneDay.total({ + unit: "hours", + relativeTo: repeatedHourDay +}), 25); + +// start after repeated hour, end >1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-11-04T00:00[America/Vancouver]"); +assert.sameValue(hours25.negated().total({ + unit: "days", + relativeTo +}), -1); +assert.sameValue(oneDay.negated().total({ + unit: "hours", + relativeTo +}), -25); + +// start before repeated hour, end <1 day after", +var totalDays = hours12.total({ + unit: "days", + relativeTo: repeatedHourDay +}); +assert(Math.abs(totalDays - 12 / 25) < Number.EPSILON); + +// start after repeated hour, end <1 day before (negative)", +var relativeTo = Temporal.ZonedDateTime.from("2019-11-03T12:00[America/Vancouver]"); +var totalDays = hours12.negated().total({ + unit: "days", + relativeTo +}); +assert(Math.abs(totalDays - -12 / 25) < Number.EPSILON); + +// Samoa skipped 24 hours", +var relativeTo = Temporal.ZonedDateTime.from("2011-12-29T12:00-10:00[Pacific/Apia]"); +var totalDays = hours25.total({ + unit: "days", + relativeTo +}); +assert(Math.abs(totalDays - (2 + 1 / 24)) < Number.EPSILON); +assert.sameValue(Temporal.Duration.from({ hours: 48 }).total({ + unit: "days", + relativeTo +}), 3); +assert.sameValue(Temporal.Duration.from({ days: 2 }).total({ + unit: "hours", + relativeTo +}), 24); +assert.sameValue(Temporal.Duration.from({ days: 3 }).total({ + unit: "hours", + relativeTo +}), 48); + +// totaling back up to days +var relativeTo = Temporal.ZonedDateTime.from("2019-11-02T00:00[America/Vancouver]"); +assert.sameValue(Temporal.Duration.from({ hours: 48 }).total({ unit: "days" }), 2); +var totalDays = Temporal.Duration.from({ hours: 48 }).total({ + unit: "days", + relativeTo +}); +assert(Math.abs(totalDays - (1 + 24 / 25)) < Number.EPSILON); + +// casts relativeTo to ZonedDateTime if possible +assert.sameValue(oneDay.total({ + unit: "hours", + relativeTo: "2019-11-03T00:00[America/Vancouver]" +}), 25); +assert.sameValue(oneDay.total({ + unit: "hours", + relativeTo: { + year: 2019, + month: 11, + day: 3, + timeZone: "America/Vancouver" + } +}), 25); + +// balances up to the next unit after rounding +var almostWeek = Temporal.Duration.from({ + days: 6, + hours: 20 +}); +var totalWeeks = almostWeek.total({ + unit: "weeks", + relativeTo: "2020-01-01" +}); +assert(Math.abs(totalWeeks - (6 + 20 / 24) / 7) < Number.EPSILON); + +// balances up to the next unit after rounding (negative) +var almostWeek = Temporal.Duration.from({ + days: -6, + hours: -20 +}); +var totalWeeks = almostWeek.total({ + unit: "weeks", + relativeTo: "2020-01-01" +}); +assert(Math.abs(totalWeeks - -((6 + 20 / 24) / 7)) < Number.EPSILON); + +// balances days up to both years and months +var twoYears = Temporal.Duration.from({ + months: 11, + days: 396 +}); +assert.sameValue(twoYears.total({ + unit: "years", + relativeTo: "2017-01-01" +}), 2); + +// balances days up to both years and months (negative) +var twoYears = Temporal.Duration.from({ + months: -11, + days: -396 +}); +assert.sameValue(twoYears.total({ + unit: "years", + relativeTo: "2017-01-01" +}), -2); diff --git a/test/staging/Temporal/Regex/old/duration.js b/test/staging/Temporal/Regex/old/duration.js new file mode 100644 index 0000000000..d78e5cdfb9 --- /dev/null +++ b/test/staging/Temporal/Regex/old/duration.js @@ -0,0 +1,268 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-duration-objects +description: Temporal.Duration works as expected +features: [Temporal] +---*/ + +function test(isoString, components) { + var {y = 0, mon = 0, w = 0, d = 0, h = 0, min = 0, s = 0, ms = 0, µs = 0, ns = 0} = components; + var duration = Temporal.Duration.from(isoString); + assert.sameValue(duration.years, y); + assert.sameValue(duration.months, mon); + assert.sameValue(duration.weeks, w); + assert.sameValue(duration.days, d); + assert.sameValue(duration.hours, h); + assert.sameValue(duration.minutes, min); + assert.sameValue(duration.seconds, s); + assert.sameValue(duration.milliseconds, ms); + assert.sameValue(duration.microseconds, µs); + assert.sameValue(duration.nanoseconds, ns); +} +var day = [ + [ + "", + {} + ], + [ + "1Y", + { y: 1 } + ], + [ + "2M", + { mon: 2 } + ], + [ + "4W", + { w: 4 } + ], + [ + "3D", + { d: 3 } + ], + [ + "1Y2M", + { + y: 1, + mon: 2 + } + ], + [ + "1Y3D", + { + y: 1, + d: 3 + } + ], + [ + "2M3D", + { + mon: 2, + d: 3 + } + ], + [ + "4W3D", + { + w: 4, + d: 3 + } + ], + [ + "1Y2M3D", + { + y: 1, + mon: 2, + d: 3 + } + ], + [ + "1Y2M4W3D", + { + y: 1, + mon: 2, + w: 4, + d: 3 + } + ] +]; +var times = [ + [ + "", + {} + ], + [ + "4H", + { h: 4 } + ], + [ + "5M", + { min: 5 } + ], + [ + "4H5M", + { + h: 4, + min: 5 + } + ] +]; +var sec = [ + [ + "", + {} + ], + [ + "6S", + { s: 6 } + ], + [ + "7.1S", + { + s: 7, + ms: 100 + } + ], + [ + "7.12S", + { + s: 7, + ms: 120 + } + ], + [ + "7.123S", + { + s: 7, + ms: 123 + } + ], + [ + "8.1234S", + { + s: 8, + ms: 123, + µs: 400 + } + ], + [ + "8.12345S", + { + s: 8, + ms: 123, + µs: 450 + } + ], + [ + "8.123456S", + { + s: 8, + ms: 123, + µs: 456 + } + ], + [ + "9.1234567S", + { + s: 9, + ms: 123, + µs: 456, + ns: 700 + } + ], + [ + "9.12345678S", + { + s: 9, + ms: 123, + µs: 456, + ns: 780 + } + ], + [ + "9.123456789S", + { + s: 9, + ms: 123, + µs: 456, + ns: 789 + } + ], + [ + "0.123S", + { ms: 123 } + ], + [ + "0,123S", + { ms: 123 } + ], + [ + "0.123456S", + { + ms: 123, + µs: 456 + } + ], + [ + "0,123456S", + { + ms: 123, + µs: 456 + } + ], + [ + "0.123456789S", + { + ms: 123, + µs: 456, + ns: 789 + } + ], + [ + "0,123456789S", + { + ms: 123, + µs: 456, + ns: 789 + } + ] +]; +var tim = sec.reduce((arr, [s, add]) => arr.concat(times.map(([p, expect]) => [ + `${ p }${ s }`, + { + ...expect, + ...add + } +])), []).slice(1); +day.slice(1).forEach(([p, expect]) => { + test(`P${ p }`, expect); + test(`p${ p }`, expect); + test(`p${ p.toLowerCase() }`, expect); +}); +tim.forEach(([p, expect]) => { + test(`PT${ p }`, expect); + test(`Pt${ p }`, expect); + test(`pt${ p.toLowerCase() }`, expect); +}); +for (var [d, dexpect] of day) { + for (var [t, texpect] of tim) { + test(`P${ d }T${ t }`, { + ...dexpect, + ...texpect + }); + test(`p${ d }T${ t.toLowerCase() }`, { + ...dexpect, + ...texpect + }); + test(`P${ d.toLowerCase() }t${ t }`, { + ...dexpect, + ...texpect + }); + test(`p${ d.toLowerCase() }t${ t.toLowerCase() }`, { + ...dexpect, + ...texpect + }); + } +} diff --git a/test/staging/Temporal/Regex/old/instant.js b/test/staging/Temporal/Regex/old/instant.js new file mode 100644 index 0000000000..9602b0fbc4 --- /dev/null +++ b/test/staging/Temporal/Regex/old/instant.js @@ -0,0 +1,264 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-instant-objects +description: Temporal.Instant works as expected +features: [Temporal] +---*/ + +function test(isoString, components) { + var [y, mon, d, h = 0, min = 0, s = 0, ms = 0, µs = 0, ns = 0] = components; + var instant = Temporal.Instant.from(isoString); + var utc = Temporal.TimeZone.from("UTC"); + var datetime = utc.getPlainDateTimeFor(instant); + assert.sameValue(datetime.year, y); + assert.sameValue(datetime.month, mon); + assert.sameValue(datetime.day, d); + assert.sameValue(datetime.hour, h); + assert.sameValue(datetime.minute, min); + assert.sameValue(datetime.second, s); + assert.sameValue(datetime.millisecond, ms); + assert.sameValue(datetime.microsecond, µs); + assert.sameValue(datetime.nanosecond, ns); +} +function generateTest(dateTimeString, zoneString, components) { + test(`${ dateTimeString }${ zoneString }`, components.slice(0, 5)); + test(`${ dateTimeString }:30${ zoneString }`, components.slice(0, 6)); + test(`${ dateTimeString }:30.123456789${ zoneString }`, components); +} +// valid strings +test("2020-01-01Z", [ + 2020, + 1, + 1, + 0, + 0, + 0 +]); +[ + "+01:00", + "+01", + "+0100", + "+01:00:00", + "+010000", + "+01:00:00.000000000", + "+010000.0" +].forEach(zoneString => { + generateTest("1976-11-18T15:23", `${ zoneString }[Europe/Vienna]`, [ + 1976, + 11, + 18, + 14, + 23, + 30, + 123, + 456, + 789 + ]); + generateTest("1976-11-18T15:23", `+01:00[${ zoneString }]`, [ + 1976, + 11, + 18, + 14, + 23, + 30, + 123, + 456, + 789 + ]); +}); +[ + "-04:00", + "-04", + "-0400", + "-04:00:00", + "-040000", + "-04:00:00.000000000", + "-040000.0" +].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString, [ + 1976, + 11, + 18, + 19, + 23, + 30, + 123, + 456, + 789 +])); +test("1976-11-18T15:23:30.1Z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 100 +]); +test("1976-11-18T15:23:30.12Z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 120 +]); +test("1976-11-18T15:23:30.123Z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123 +]); +test("1976-11-18T15:23:30.1234Z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123, + 400 +]); +test("1976-11-18T15:23:30.12345Z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123, + 450 +]); +test("1976-11-18T15:23:30.123456Z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123, + 456 +]); +test("1976-11-18T15:23:30.1234567Z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123, + 456, + 700 +]); +test("1976-11-18T15:23:30.12345678Z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123, + 456, + 780 +]); +generateTest("1976-11-18T15:23", "z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123, + 456, + 789 +]); +test("1976-11-18T15:23:30,1234Z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123, + 400 +]); +[ + "\u221204:00", + "\u221204", + "\u22120400" +].forEach(offset => test(`1976-11-18T15:23:30.1234${ offset }`, [ + 1976, + 11, + 18, + 19, + 23, + 30, + 123, + 400 +])); +test("\u2212009999-11-18T15:23:30.1234Z", [ + -9999, + 11, + 18, + 15, + 23, + 30, + 123, + 400 +]); +test("1976-11-18T152330Z", [ + 1976, + 11, + 18, + 15, + 23, + 30 +]); +test("1976-11-18T152330.1234Z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123, + 400 +]); +test("19761118T15:23:30Z", [ + 1976, + 11, + 18, + 15, + 23, + 30 +]); +test("19761118T152330Z", [ + 1976, + 11, + 18, + 15, + 23, + 30 +]); +test("19761118T152330.1234Z", [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123, + 400 +]); +test("1976-11-18T15Z", [ + 1976, + 11, + 18, + 15 +]); + diff --git a/test/staging/Temporal/Regex/old/plaindate.js b/test/staging/Temporal/Regex/old/plaindate.js new file mode 100644 index 0000000000..30c23a84f9 --- /dev/null +++ b/test/staging/Temporal/Regex/old/plaindate.js @@ -0,0 +1,81 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-plainedate-objects +description: Temporal.PlainDate works as expected +features: [Temporal] +---*/ + +function test(isoString, components) { + var [y, m, d, cid = "iso8601"] = components; + var date = Temporal.PlainDate.from(isoString); + assert.sameValue(date.year, y); + assert.sameValue(date.month, m); + assert.sameValue(date.day, d); + assert.sameValue(date.calendar.id, cid); +} +function generateTest(dateTimeString, zoneString) { + var components = [ + 1976, + 11, + 18 + ]; + test(`${ dateTimeString }${ zoneString }`, components); + test(`${ dateTimeString }:30${ zoneString }`, components); + test(`${ dateTimeString }:30.123456789${ zoneString }`, components); +} +[ + "+0100[Europe/Vienna]", + "[Europe/Vienna]", + "+01:00[Custom/Vienna]", + "-0400", + "-04:00:00.000000000", + "+01:00[+01:00]", + "+01:00[+0100]", + "" +].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString)); +[ + "1", + "12", + "123", + "1234", + "12345", + "123456", + "1234567", + "12345678" +].forEach(decimals => test(`1976-11-18T15:23:30.${ decimals }`, [ + 1976, + 11, + 18 +])); +test("1976-11-18T15:23:30,1234", [ + 1976, + 11, + 18 +]); +test("\u2212009999-11-18", [ + -9999, + 11, + 18 +]); +test("1976-11-18T15", [ + 1976, + 11, + 18 +]); +[ + "", + "+01:00[Europe/Vienna]", + "[Europe/Vienna]", + "+01:00[Custom/Vienna]" +].forEach(zoneString => test(`1976-11-18T15:23:30.123456789${ zoneString }[u-ca=iso8601]`, [ + 1976, + 11, + 18 +])); +test("1976-11-18[u-ca=iso8601]", [ + 1976, + 11, + 18 +]); diff --git a/test/staging/Temporal/Regex/old/plaindatetime.js b/test/staging/Temporal/Regex/old/plaindatetime.js new file mode 100644 index 0000000000..5771476f8d --- /dev/null +++ b/test/staging/Temporal/Regex/old/plaindatetime.js @@ -0,0 +1,71 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-plaindatetime-objects +description: Temporal.PlainDateTime works as expected +features: [Temporal] +---*/ + +function test(isoString, components) { + var [y, mon, d, h = 0, min = 0, s = 0, ms = 0, µs = 0, ns = 0, cid = "iso8601"] = components; + var datetime = Temporal.PlainDateTime.from(isoString); + assert.sameValue(datetime.year, y); + assert.sameValue(datetime.month, mon); + assert.sameValue(datetime.day, d); + assert.sameValue(datetime.hour, h); + assert.sameValue(datetime.minute, min); + assert.sameValue(datetime.second, s); + assert.sameValue(datetime.millisecond, ms); + assert.sameValue(datetime.microsecond, µs); + assert.sameValue(datetime.nanosecond, ns); + assert.sameValue(datetime.calendar.id, cid); +} +function generateTest(dateTimeString, zoneString) { + var components = [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123, + 456, + 789 + ]; + test(`${ dateTimeString }${ zoneString }`, components.slice(0, 5)); + test(`${ dateTimeString }:30${ zoneString }`, components.slice(0, 6)); + test(`${ dateTimeString }:30.123456789${ zoneString }`, components); +} + +//valid strings +[ + "+0100[Europe/Vienna]", + "+01:00[Europe/Vienna]", + "[Europe/Vienna]", + "+01:00[Custom/Vienna]", + "-0400", + "-04:00", + "-04:00:00.000000000", + "+010000.0[Europe/Vienna]", + "+01:00[+01:00]", + "+01:00[+0100]", + "" +].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString)); +[ + "", + "+01:00[Europe/Vienna]", + "+01:00[Custom/Vienna]", + "[Europe/Vienna]" +].forEach(zoneString => test(`1976-11-18T15:23:30.123456789${ zoneString }[u-ca=iso8601]`, [ + 1976, + 11, + 18, + 15, + 23, + 30, + 123, + 456, + 789 +])); + diff --git a/test/staging/Temporal/Regex/old/plainmonthday.js b/test/staging/Temporal/Regex/old/plainmonthday.js new file mode 100644 index 0000000000..6623d912ca --- /dev/null +++ b/test/staging/Temporal/Regex/old/plainmonthday.js @@ -0,0 +1,75 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-plainmonthday-objects +description: Temporal.PlainMonthDay works as expected +features: [Temporal] +---*/ + +function test(isoString, components) { + var [m, d, cid = "iso8601"] = components; + var monthDay = Temporal.PlainMonthDay.from(isoString); + assert.sameValue(monthDay.monthCode, `M${ m.toString().padStart(2, "0") }`); + assert.sameValue(monthDay.day, d); + assert.sameValue(monthDay.calendar.id, cid); +} +function generateTest(dateTimeString, zoneString) { + var components = [ + 11, + 18 + ]; + test(`${ dateTimeString }${ zoneString }`, components); + test(`${ dateTimeString }:30${ zoneString }`, components); + test(`${ dateTimeString }:30.123456789${ zoneString }`, components); +} +[ + "+0100[Europe/Vienna]", + "[Europe/Vienna]", + "+01:00[Custom/Vienna]", + "-0400", + "-04:00:00.000000000", + "+010000.0[Europe/Vienna]", + "+01:00[+01:00]", + "+01:00[+0100]", + "" +].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString)); +[ + "1", + "12", + "123", + "1234", + "12345", + "123456", + "1234567", + "12345678" +].forEach(decimals => test(`1976-11-18T15:23:30.${ decimals }`, [ + 11, + 18 +])); +[ + "1976-11-18T15:23:30,1234", + "\u2212009999-11-18", + "19761118", + "+199999-11-18", + "+1999991118", + "-000300-11-18", + "-0003001118", + "15121118" +].forEach(str => test(str, [ + 11, + 18 +])); +[ + "", + "+01:00[Europe/Vienna]", + "[Europe/Vienna]", + "+01:00[Custom/Vienna]" +].forEach(zoneString => test(`1976-11-18T15:23:30.123456789${ zoneString }[u-ca=iso8601]`, [ + 11, + 18 +])); +test("1972-11-18[u-ca=iso8601]", [ + 11, + 18 +]); diff --git a/test/staging/Temporal/Regex/old/plaintime.js b/test/staging/Temporal/Regex/old/plaintime.js new file mode 100644 index 0000000000..130303692c --- /dev/null +++ b/test/staging/Temporal/Regex/old/plaintime.js @@ -0,0 +1,63 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-plaintime-objects +description: Temporal.PlainTime works as expected +features: [Temporal] +---*/ + +function test(isoString, components) { + var [h = 0, m = 0, s = 0, ms = 0, µs = 0, ns = 0] = components; + var time = Temporal.PlainTime.from(isoString); + assert.sameValue(time.hour, h); + assert.sameValue(time.minute, m); + assert.sameValue(time.second, s); + assert.sameValue(time.millisecond, ms); + assert.sameValue(time.microsecond, µs); + assert.sameValue(time.nanosecond, ns); +} +function generateTest(dateTimeString, zoneString) { + var components = [ + 15, + 23, + 30, + 123, + 456, + 789 + ]; + test(`${ dateTimeString }${ zoneString }`, components.slice(0, 2)); + test(`${ dateTimeString }:30${ zoneString }`, components.slice(0, 3)); + test(`${ dateTimeString }:30.123456789${ zoneString }`, components); +} +[ + "+0100[Europe/Vienna]", + "+01:00[Custom/Vienna]", + "-0400", + "-04:00:00.000000000", + "+010000.0[Europe/Vienna]", + "+01:00[+01:00]", + "+01:00[+0100]", + "" +].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString)); +[ + "+01:00[Europe/Vienna]", + "[Europe/Vienna]", + "+01:00[Custom/Vienna]", + "-04:00", + "Z", + "" +].forEach(zoneStr => test(`15${ zoneStr }`, [15])); +[ + "", + "+01:00[Europe/Vienna]", + "[Europe/Vienna]", + "+01:00[Custom/Vienna]" +].forEach(zoneString => test(`1976-11-18T15:23:30.123456789${ zoneString }[u-ca=iso8601]`, [ + 15, + 23, + 30, + 123, + 456, + 789 +])); diff --git a/test/staging/Temporal/Regex/old/plainyearmonth.js b/test/staging/Temporal/Regex/old/plainyearmonth.js new file mode 100644 index 0000000000..1f34237d41 --- /dev/null +++ b/test/staging/Temporal/Regex/old/plainyearmonth.js @@ -0,0 +1,106 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-plainyearmonth-objects +description: Temporal.PlainYearMonth works as expected +features: [Temporal] +---*/ + +function test(isoString, components) { + var [y, m, cid = "iso8601"] = components; + var yearMonth = Temporal.PlainYearMonth.from(isoString); + assert.sameValue(yearMonth.year, y); + assert.sameValue(yearMonth.month, m); + assert.sameValue(yearMonth.calendar.id, cid); +} +function generateTest(dateTimeString, zoneString) { + var components = [ + 1976, + 11 + ]; + test(`${ dateTimeString }${ zoneString }`, components); + test(`${ dateTimeString }:30${ zoneString }`, components); + test(`${ dateTimeString }:30.123456789${ zoneString }`, components); +} +[ + "+0100[Europe/Vienna]", + "[Europe/Vienna]", + "+01:00[Custom/Vienna]", + "-0400", + "-04:00:00.000000000", + "+01:00:00.0[Europe/Vienna]", + "+01:00[+01:00]", + "+01:00[+0100]", + "" +].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString)); +[ + "1", + "12", + "123", + "1234", + "12345", + "123456", + "1234567", + "12345678" +].forEach(decimals => test(`1976-11-18T15:23:30.${ decimals }`, [ + 1976, + 11 +])); +test("1976-11-18T15:23:30,1234", [ + 1976, + 11 +]); +test("19761118", [ + 1976, + 11 +]); +test("+199999-11-18", [ + 199999, + 11 +]); +test("+1999991118", [ + 199999, + 11 +]); +test("-000300-11-18", [ + -300, + 11 +]); +test("-0003001118", [ + -300, + 11 +]); +test("1512-11-18", [ + 1512, + 11 +]); +test("+199999-11", [ + 199999, + 11 +]); +test("+19999911", [ + 199999, + 11 +]); +test("-000300-11", [ + -300, + 11 +]); +test("-00030011", [ + -300, + 11 +]); +[ + "", + "+01:00[Europe/Vienna]", + "[Europe/Vienna]", + "+01:00[Custom/Vienna]" +].forEach(zoneString => test(`1976-11-18T15:23:30.123456789${ zoneString }[u-ca=iso8601]`, [ + 1976, + 11 +])); +test("1976-11-01[u-ca=iso8601]", [ + 1976, + 11 +]); diff --git a/test/staging/Temporal/Regex/old/timezone.js b/test/staging/Temporal/Regex/old/timezone.js new file mode 100644 index 0000000000..93b3b0ba12 --- /dev/null +++ b/test/staging/Temporal/Regex/old/timezone.js @@ -0,0 +1,101 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-timezone-objects +description: Temporal.TimeZone works as expected +features: [Temporal] +---*/ + +function test(offsetString, expectedName) { + var timeZone = Temporal.TimeZone.from(offsetString); + assert.sameValue(timeZone.id, expectedName); +} +function generateTest(dateTimeString, zoneString, expectedName) { + test(`${ dateTimeString }${ zoneString }`, expectedName); + test(`${ dateTimeString }:30${ zoneString }`, expectedName); + test(`${ dateTimeString }:30.123456789${ zoneString }`, expectedName); +} +[ + "+01:00", + "+01", + "+0100", + "+01:00:00", + "+010000", + "+01:00:00.000000000", + "+010000.0" +].forEach(zoneString => { + generateTest("1976-11-18T15:23", `${ zoneString }[Europe/Vienna]`, "Europe/Vienna"); + generateTest("1976-11-18T15:23", `+01:00[${ zoneString }]`, "+01:00"); +}); +[ + "-04:00", + "-04", + "-0400", + "-04:00:00", + "-040000", + "-04:00:00.000000000", + "-040000.0" +].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString, "-04:00")); +[ + "1", + "12", + "123", + "1234", + "12345", + "123456", + "1234567", + "12345678" +].forEach(decimals => { + test(`1976-11-18T15:23:30.${ decimals }Z`, "UTC"); + test(`1976-11-18T15:23+01:00[+01:00:00.${ decimals }]`, `+01:00:00.${ decimals }`); +}); +generateTest("1976-11-18T15:23", "z", "UTC"); +test("1976-11-18T15:23:30,1234Z", "UTC"); +test("1976-11-18T15:23-04:00:00,000000000", "-04:00"); +test("1976-11-18T15:23+010000,0[Europe/Vienna]", "Europe/Vienna"); +[ + "\u221204:00", + "\u221204", + "\u22120400" +].forEach(offset => test(`1976-11-18T15:23${ offset }`, "-04:00")); +[ + "1976-11-18T152330", + "1976-11-18T152330.1234", + "19761118T15:23:30", + "19761118T152330", + "19761118T152330.1234", + "1976-11-18T15" +].forEach(dateTimeString => { + [ + "+01:00", + "+01", + "+0100", + "" + ].forEach(zoneString => test(`${ dateTimeString }${ zoneString }[Europe/Vienna]`, "Europe/Vienna")); + [ + "-04:00", + "-04", + "-0400" + ].forEach(zoneString => test(`${ dateTimeString }${ zoneString }`, "-04:00")); + test(`${ dateTimeString }Z`, "UTC"); +}); +test("-0000", "+00:00"); +test("-00:00", "+00:00"); +test("+00", "+00:00"); +test("-00", "+00:00"); +test("+03", "+03:00"); +test("-03", "-03:00"); +test("\u22120000", "+00:00"); +test("\u221200:00", "+00:00"); +test("\u221200", "+00:00"); +test("\u22120300", "-03:00"); +test("\u221203:00", "-03:00"); +test("\u221203", "-03:00"); +test("+030000.0", "+03:00"); +test("-03:00:00", "-03:00"); +test("-03:00:00.000000000", "-03:00"); +test("1976-11-18T15:23:30.123456789Z[u-ca=iso8601]", "UTC"); +test("1976-11-18T15:23:30.123456789-04:00[u-ca=iso8601]", "-04:00"); +test("1976-11-18T15:23:30.123456789[Europe/Vienna][u-ca=iso8601]", "Europe/Vienna"); +test("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna][u-ca=iso8601]", "Europe/Vienna"); diff --git a/test/staging/Temporal/TimeZone/old/dst-change.js b/test/staging/Temporal/TimeZone/old/dst-change.js new file mode 100644 index 0000000000..bcd8372860 --- /dev/null +++ b/test/staging/Temporal/TimeZone/old/dst-change.js @@ -0,0 +1,26 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-timezone-objects +description: with DST change +features: [Temporal] +---*/ + +// clock moving forward +var zone = new Temporal.TimeZone("Europe/Berlin"); +var dtm = new Temporal.PlainDateTime(2019, 3, 31, 2, 45); +assert.sameValue(`${ zone.getInstantFor(dtm) }`, "2019-03-31T01:45:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "earlier" }) }`, "2019-03-31T00:45:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "later" }) }`, "2019-03-31T01:45:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "compatible" }) }`, "2019-03-31T01:45:00Z"); +assert.throws(RangeError, () => zone.getInstantFor(dtm, { disambiguation: "reject" })); + +// clock moving backward +var zone = new Temporal.TimeZone("America/Sao_Paulo"); +var dtm = new Temporal.PlainDateTime(2019, 2, 16, 23, 45); +assert.sameValue(`${ zone.getInstantFor(dtm) }`, "2019-02-17T01:45:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "earlier" }) }`, "2019-02-17T01:45:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "later" }) }`, "2019-02-17T02:45:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "compatible" }) }`, "2019-02-17T01:45:00Z"); +assert.throws(RangeError, () => zone.getInstantFor(dtm, { disambiguation: "reject" })); diff --git a/test/staging/Temporal/TimeZone/old/getInstantFor-disambiguation.js b/test/staging/Temporal/TimeZone/old/getInstantFor-disambiguation.js new file mode 100644 index 0000000000..d205717513 --- /dev/null +++ b/test/staging/Temporal/TimeZone/old/getInstantFor-disambiguation.js @@ -0,0 +1,47 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-timezone-objects +description: getInstantFor disambiguation +features: [Temporal] +---*/ + +var dtm = new Temporal.PlainDateTime(2019, 2, 16, 23, 45); + +// with constant offset +var zone = Temporal.TimeZone.from("+03:30"); +for (var disambiguation of [ + undefined, + "compatible", + "earlier", + "later", + "reject" + ]) { + assert(zone.getInstantFor(dtm, { disambiguation }) instanceof Temporal.Instant); +} + +// with daylight saving change - Fall +var zone = Temporal.TimeZone.from("America/Sao_Paulo"); +assert.sameValue(`${ zone.getInstantFor(dtm) }`, "2019-02-17T01:45:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "earlier" }) }`, "2019-02-17T01:45:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "later" }) }`, "2019-02-17T02:45:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "compatible" }) }`, "2019-02-17T01:45:00Z"); +assert.throws(RangeError, () => zone.getInstantFor(dtm, { disambiguation: "reject" })); + +// with daylight saving change - Spring +var dtmLA = new Temporal.PlainDateTime(2020, 3, 8, 2, 30); +var zone = Temporal.TimeZone.from("America/Los_Angeles"); +assert.sameValue(`${ zone.getInstantFor(dtmLA) }`, "2020-03-08T10:30:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtmLA, { disambiguation: "earlier" }) }`, "2020-03-08T09:30:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtmLA, { disambiguation: "later" }) }`, "2020-03-08T10:30:00Z"); +assert.sameValue(`${ zone.getInstantFor(dtmLA, { disambiguation: "compatible" }) }`, "2020-03-08T10:30:00Z"); +assert.throws(RangeError, () => zone.getInstantFor(dtmLA, { disambiguation: "reject" })); + +// throws on bad disambiguation +var zone = Temporal.TimeZone.from("+03:30"); +[ + "", + "EARLIER", + "test", +].forEach(disambiguation => assert.throws(RangeError, () => zone.getInstantFor(dtm, { disambiguation }))); diff --git a/test/staging/Temporal/TimeZone/old/getInstantFor.js b/test/staging/Temporal/TimeZone/old/getInstantFor.js new file mode 100644 index 0000000000..c86834e771 --- /dev/null +++ b/test/staging/Temporal/TimeZone/old/getInstantFor.js @@ -0,0 +1,58 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-timezone-objects +description: Temporal.TimeZone.prototype.getInstantFor() works +features: [Temporal] +---*/ + + +// recent date +var dt = Temporal.PlainDateTime.from("2019-10-29T10:46:38.271986102"); +var tz = Temporal.TimeZone.from("Europe/Amsterdam"); +assert.sameValue(`${ tz.getInstantFor(dt) }`, "2019-10-29T09:46:38.271986102Z"); + +// year ≤ 99 +var dt = Temporal.PlainDateTime.from("0098-10-29T10:46:38.271986102"); +var tz = Temporal.TimeZone.from("+06:00"); +assert.sameValue(`${ tz.getInstantFor(dt) }`, "0098-10-29T04:46:38.271986102Z"); +dt = Temporal.PlainDateTime.from("+000098-10-29T10:46:38.271986102"); +assert.sameValue(`${ tz.getInstantFor(dt) }`, "0098-10-29T04:46:38.271986102Z"); + +// year < 1 +var dt = Temporal.PlainDateTime.from("0000-10-29T10:46:38.271986102"); +var tz = Temporal.TimeZone.from("+06:00"); +assert.sameValue(`${ tz.getInstantFor(dt) }`, "0000-10-29T04:46:38.271986102Z"); +dt = Temporal.PlainDateTime.from("+000000-10-29T10:46:38.271986102"); +assert.sameValue(`${ tz.getInstantFor(dt) }`, "0000-10-29T04:46:38.271986102Z"); +dt = Temporal.PlainDateTime.from("-001000-10-29T10:46:38.271986102"); +assert.sameValue(`${ tz.getInstantFor(dt) }`, "-001000-10-29T04:46:38.271986102Z"); + +// year 0 leap day +var dt = Temporal.PlainDateTime.from("0000-02-29T00:00"); +var tz = Temporal.TimeZone.from("Europe/London"); +assert.sameValue(`${ tz.getInstantFor(dt) }`, "0000-02-29T00:01:15Z"); +dt = Temporal.PlainDateTime.from("+000000-02-29T00:00"); +assert.sameValue(`${ tz.getInstantFor(dt) }`, "0000-02-29T00:01:15Z"); + +// outside of Instant range +var max = Temporal.PlainDateTime.from("+275760-09-13T23:59:59.999999999"); +var offsetTz = Temporal.TimeZone.from("-01:00"); +assert.throws(RangeError, () => offsetTz.getInstantFor(max)); +var namedTz = Temporal.TimeZone.from("America/Godthab"); +assert.throws(RangeError, () => namedTz.getInstantFor(max)); + +// casts argument +var tz = Temporal.TimeZone.from("Europe/Amsterdam"); +assert.sameValue(`${ tz.getInstantFor("2019-10-29T10:46:38.271986102") }`, "2019-10-29T09:46:38.271986102Z"); +assert.sameValue(`${ tz.getInstantFor({ + year: 2019, + month: 10, + day: 29, + hour: 10, + minute: 46, + second: 38 +}) }`, "2019-10-29T09:46:38Z"); + + diff --git a/test/staging/Temporal/TimeZone/old/getNextTransition.js b/test/staging/Temporal/TimeZone/old/getNextTransition.js new file mode 100644 index 0000000000..8a3e83035c --- /dev/null +++ b/test/staging/Temporal/TimeZone/old/getNextTransition.js @@ -0,0 +1,30 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-timezone-objects +description: Temporal.TimeZone.prototype.getNextTransition() works as expected +features: [Temporal] +---*/ + +var nyc = Temporal.TimeZone.from("America/New_York"); +var noTransitionTZ = Temporal.TimeZone.from("Etc/GMT+10"); + +// should not have bug #510 +var a1 = Temporal.Instant.from("2019-04-16T21:01Z"); +var a2 = Temporal.Instant.from("1800-01-01T00:00Z"); +assert.sameValue(nyc.getNextTransition(a1).toString(), "2019-11-03T06:00:00Z"); +assert.sameValue(nyc.getNextTransition(a2).toString(), "1883-11-18T17:00:00Z"); + +// should not return the same as its input if the input is a transition point +var inst = Temporal.Instant.from("2019-01-01T00:00Z"); +assert.sameValue(`${ nyc.getNextTransition(inst) }`, "2019-03-10T07:00:00Z"); +assert.sameValue(`${ nyc.getNextTransition(nyc.getNextTransition(inst)) }`, "2019-11-03T06:00:00Z"); + +// should work for timezones with no scheduled transitions in the near future +var start = Temporal.Instant.from("1945-10-15T13:00:00Z"); +assert.sameValue(noTransitionTZ.getNextTransition(start), null); + +// casts argument +assert.sameValue(`${ nyc.getNextTransition("2019-04-16T21:01Z") }`, "2019-11-03T06:00:00Z"); + diff --git a/test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js b/test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js new file mode 100644 index 0000000000..74fd1ab31c --- /dev/null +++ b/test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js @@ -0,0 +1,44 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-timezone-objects +description: Temporal.TimeZone.prototype.getPossibleInstantsFor() works as expected +includes: [deepEqual.js] +features: [Temporal] +---*/ + + +// with constant offset +var zone = Temporal.TimeZone.from("+03:30"); +var dt = Temporal.PlainDateTime.from("2019-02-16T23:45"); +assert.deepEqual(zone.getPossibleInstantsFor(dt).map(a => `${ a }`), ["2019-02-16T20:15:00Z"]); + +// with clock moving forward +var zone = Temporal.TimeZone.from("Europe/Berlin"); +var dt = Temporal.PlainDateTime.from("2019-03-31T02:45"); +assert.deepEqual(zone.getPossibleInstantsFor(dt), []); + +// with clock moving backward +var zone = Temporal.TimeZone.from("America/Sao_Paulo"); +var dt = Temporal.PlainDateTime.from("2019-02-16T23:45"); +assert.deepEqual(zone.getPossibleInstantsFor(dt).map(a => `${ a }`), [ + "2019-02-17T01:45:00Z", + "2019-02-17T02:45:00Z" +]); + +// casts argument +var tz = Temporal.TimeZone.from("+03:30"); +assert.deepEqual(tz.getPossibleInstantsFor({ + year: 2019, + month: 2, + day: 16, + hour: 23, + minute: 45, + second: 30 +}).map(a => `${ a }`), ["2019-02-16T20:15:30Z"]); +assert.deepEqual(tz.getPossibleInstantsFor("2019-02-16T23:45:30").map(a => `${ a }`), ["2019-02-16T20:15:30Z"]); + +// object must contain at least the required properties +var tz = Temporal.TimeZone.from("Europe/Amsterdam"); +assert.throws(TypeError, () => tz.getPossibleInstantsFor({ year: 2019 })); diff --git a/test/staging/Temporal/TimeZone/old/getPreviousTransition.js b/test/staging/Temporal/TimeZone/old/getPreviousTransition.js new file mode 100644 index 0000000000..797ddba382 --- /dev/null +++ b/test/staging/Temporal/TimeZone/old/getPreviousTransition.js @@ -0,0 +1,24 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-timezone-objects +description: Temporal.TimeZone.prototype.getPreviousTransition() works +features: [Temporal] +---*/ + +var london = Temporal.TimeZone.from("Europe/London"); + +// should return first and last transition +var a1 = Temporal.Instant.from("2020-06-11T21:01Z"); +var a2 = Temporal.Instant.from("1848-01-01T00:00Z"); +assert.sameValue(london.getPreviousTransition(a1).toString(), "2020-03-29T01:00:00Z"); +assert.sameValue(london.getPreviousTransition(a2).toString(), "1847-12-01T00:01:15Z"); + +// should not return the same as its input if the input is a transition point +var inst = Temporal.Instant.from("2020-06-01T00:00Z"); +assert.sameValue(`${ london.getPreviousTransition(inst) }`, "2020-03-29T01:00:00Z"); +assert.sameValue(`${ london.getPreviousTransition(london.getPreviousTransition(inst)) }`, "2019-10-27T01:00:00Z"); + +// casts argument +assert.sameValue(`${ london.getPreviousTransition("2020-06-11T21:01Z") }`, "2020-03-29T01:00:00Z"); diff --git a/test/staging/Temporal/TimeZone/old/subminute-offset.js b/test/staging/Temporal/TimeZone/old/subminute-offset.js new file mode 100644 index 0000000000..d87fa63173 --- /dev/null +++ b/test/staging/Temporal/TimeZone/old/subminute-offset.js @@ -0,0 +1,17 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-timezone-objects +description: sub-minute offset +features: [Temporal] +---*/ + +var zone = new Temporal.TimeZone("Europe/Amsterdam"); +var inst = Temporal.Instant.from("1900-01-01T12:00Z"); +var dtm = Temporal.PlainDateTime.from("1900-01-01T12:00"); +assert.sameValue(zone.id, `${ zone }`) +assert.sameValue(zone.getOffsetNanosecondsFor(inst), 1172000000000) +assert.sameValue(`${ zone.getInstantFor(dtm) }`, "1900-01-01T11:40:28Z") +assert.sameValue(`${ zone.getNextTransition(inst) }`, "1916-04-30T23:40:28Z") +assert.sameValue(zone.getPreviousTransition(inst), null) diff --git a/test/staging/Temporal/TimeZone/old/timezone-america-la.js b/test/staging/Temporal/TimeZone/old/timezone-america-la.js new file mode 100644 index 0000000000..5ed6a2b3ad --- /dev/null +++ b/test/staging/Temporal/TimeZone/old/timezone-america-la.js @@ -0,0 +1,28 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-timezone-objects +description: America/Los_Angeles +features: [Temporal] +---*/ + +var zone = new Temporal.TimeZone("America/Los_Angeles"); +var inst = new Temporal.Instant(0n); +var dtm = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789); +assert.sameValue(zone.id, `${ zone }`) +assert.sameValue(zone.getOffsetNanosecondsFor(inst), -8 * 3600000000000) +assert.sameValue(zone.getOffsetStringFor(inst), "-08:00") +assert(zone.getInstantFor(dtm) instanceof Temporal.Instant) +for (var i = 0, txn = inst; i < 4; i++) { + var transition = zone.getNextTransition(txn); + assert(transition instanceof Temporal.Instant); + assert(!transition.equals(txn)); + txn = transition; +} +for (var i = 0, txn = inst; i < 4; i++) { + var transition = zone.getPreviousTransition(txn); + assert(transition instanceof Temporal.Instant); + assert(!transition.equals(txn)); + txn = transition; +} diff --git a/test/staging/Temporal/TimeZone/old/timezone-offset.js b/test/staging/Temporal/TimeZone/old/timezone-offset.js new file mode 100644 index 0000000000..31ffd7acb1 --- /dev/null +++ b/test/staging/Temporal/TimeZone/old/timezone-offset.js @@ -0,0 +1,21 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-timezone-objects +description: +01:00 +features: [Temporal] +---*/ + +var zone = new Temporal.TimeZone("+01:00"); +var inst = Temporal.Instant.fromEpochSeconds(Math.floor(Math.random() * 1000000000)); +var dtm = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789); +assert.sameValue(zone.id, `${ zone }`) +assert.sameValue(zone.getOffsetNanosecondsFor(inst), 3600000000000) +assert(zone.getPlainDateTimeFor(inst) instanceof Temporal.PlainDateTime) +assert(zone.getInstantFor(dtm) instanceof Temporal.Instant) +assert.sameValue(zone.getNextTransition(inst), null) +assert.sameValue(zone.getPreviousTransition(inst), null) + +// wraps around to the next day +assert.sameValue(`${ zone.getPlainDateTimeFor(Temporal.Instant.from("2020-02-06T23:59Z")) }`, "2020-02-07T00:59:00") diff --git a/test/staging/Temporal/TimeZone/old/timezone-utc-offset.js b/test/staging/Temporal/TimeZone/old/timezone-utc-offset.js new file mode 100644 index 0000000000..4abd2d1ee9 --- /dev/null +++ b/test/staging/Temporal/TimeZone/old/timezone-utc-offset.js @@ -0,0 +1,18 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-timezone-objects +description: UTC +features: [Temporal] +---*/ + +var zone = new Temporal.TimeZone("UTC"); +var inst = Temporal.Instant.fromEpochSeconds(Math.floor(Math.random() * 1000000000)); +var dtm = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789); +assert.sameValue(zone.id, `${ zone }`) +assert.sameValue(zone.getOffsetNanosecondsFor(inst), 0) +assert(zone.getPlainDateTimeFor(inst) instanceof Temporal.PlainDateTime) +assert(zone.getInstantFor(dtm) instanceof Temporal.Instant) +assert.sameValue(zone.getNextTransition(inst), null) +assert.sameValue(zone.getPreviousTransition(inst), null) diff --git a/test/staging/Temporal/UserCalendar/old/calendar-extra-fields.js b/test/staging/Temporal/UserCalendar/old/calendar-extra-fields.js new file mode 100644 index 0000000000..ee3b006284 --- /dev/null +++ b/test/staging/Temporal/UserCalendar/old/calendar-extra-fields.js @@ -0,0 +1,152 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: calendar with extra fields +features: [Temporal] +---*/ + +class SeasonCalendar extends Temporal.Calendar { + constructor() { + super("iso8601"); + } + toString() { + return "season"; + } + month(date) { + var {isoMonth} = date.getISOFields(); + return (isoMonth - 1) % 3 + 1; + } + monthCode(date) { + return `M${ this.month(date).toString().padStart(2, "0") }`; + } + season(date) { + var {isoMonth} = date.getISOFields(); + return Math.floor((isoMonth - 1) / 3) + 1; + } + _isoMonthCode(fields) { + var month = fields.month || +fields.monthCode.slice(1); + return `M${ ((fields.season - 1) * 3 + month).toString().padStart(2, "0") }`; + } + dateFromFields(fields, options) { + var monthCode = this._isoMonthCode(fields); + delete fields.month; + return super.dateFromFields({ + ...fields, + monthCode + }, options); + } + yearMonthFromFields(fields, options) { + var monthCode = this._isoMonthCode(fields); + delete fields.month; + return super.yearMonthFromFields({ + ...fields, + monthCode + }, options); + } + monthDayFromFields(fields, options) { + var monthCode = this._isoMonthCode(fields); + delete fields.month; + return super.monthDayFromFields({ + ...fields, + monthCode + }, options); + } + fields(fields) { + fields = fields.slice(); + if (fields.includes("month") || fields.includes("monthCode")) + fields.push("season"); + return fields; + } +} +var calendar = new SeasonCalendar(); +var datetime = new Temporal.PlainDateTime(2019, 9, 15, 0, 0, 0, 0, 0, 0, calendar); +var date = new Temporal.PlainDate(2019, 9, 15, calendar); +var yearmonth = new Temporal.PlainYearMonth(2019, 9, calendar); +var monthday = new Temporal.PlainMonthDay(9, 15, calendar); +var zoned = new Temporal.ZonedDateTime(1568505600000000000n, "UTC", calendar); +var propDesc = { + get() { + return this.calendar.season(this); + }, + configurable: true +}; +Object.defineProperty(Temporal.PlainDateTime.prototype, "season", propDesc); +Object.defineProperty(Temporal.PlainDate.prototype, "season", propDesc); +Object.defineProperty(Temporal.PlainYearMonth.prototype, "season", propDesc); +Object.defineProperty(Temporal.PlainMonthDay.prototype, "season", propDesc); +Object.defineProperty(Temporal.ZonedDateTime.prototype, "season", propDesc); + +// property getter works +assert.sameValue(datetime.season, 3); +assert.sameValue(datetime.month, 3); +assert.sameValue(datetime.monthCode, "M03"); +assert.sameValue(date.season, 3); +assert.sameValue(date.month, 3); +assert.sameValue(date.monthCode, "M03"); +assert.sameValue(yearmonth.season, 3); +assert.sameValue(yearmonth.month, 3); +assert.sameValue(yearmonth.monthCode, "M03"); +assert.sameValue(monthday.season, 3); +assert.sameValue(monthday.monthCode, "M03"); +assert.sameValue(zoned.season, 3); +assert.sameValue(zoned.month, 3); +assert.sameValue(zoned.monthCode, "M03"); + +// accepts season in from() +assert.sameValue(`${ Temporal.PlainDateTime.from({ + year: 2019, + season: 3, + month: 3, + day: 15, + calendar +}) }`, "2019-09-15T00:00:00[u-ca=season]"); +assert.sameValue(`${ Temporal.PlainDate.from({ + year: 2019, + season: 3, + month: 3, + day: 15, + calendar +}) }`, "2019-09-15[u-ca=season]"); +assert.sameValue(`${ Temporal.PlainYearMonth.from({ + year: 2019, + season: 3, + month: 3, + calendar +}) }`, "2019-09-01[u-ca=season]"); +assert.sameValue(`${ Temporal.PlainMonthDay.from({ + season: 3, + monthCode: "M03", + day: 15, + calendar +}) }`, "1972-09-15[u-ca=season]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from({ + year: 2019, + season: 3, + month: 3, + day: 15, + timeZone: "UTC", + calendar +}) }`, "2019-09-15T00:00:00+00:00[UTC][u-ca=season]"); + +// accepts season in with() +assert.sameValue(`${ datetime.with({ season: 2 }) }`, "2019-06-15T00:00:00[u-ca=season]"); +assert.sameValue(`${ date.with({ season: 2 }) }`, "2019-06-15[u-ca=season]"); +assert.sameValue(`${ yearmonth.with({ season: 2 }) }`, "2019-06-01[u-ca=season]"); +assert.sameValue(`${ monthday.with({ season: 2 }) }`, "1972-06-15[u-ca=season]"); +assert.sameValue(`${ zoned.with({ season: 2 }) }`, "2019-06-15T00:00:00+00:00[UTC][u-ca=season]"); + +// translates month correctly in with() +assert.sameValue(`${ datetime.with({ month: 2 }) }`, "2019-08-15T00:00:00[u-ca=season]"); +assert.sameValue(`${ date.with({ month: 2 }) }`, "2019-08-15[u-ca=season]"); +assert.sameValue(`${ yearmonth.with({ month: 2 }) }`, "2019-08-01[u-ca=season]"); +assert.sameValue(`${ monthday.with({ monthCode: "M02" }) }`, "1972-08-15[u-ca=season]"); +assert.sameValue(`${ zoned.with({ month: 2 }) }`, "2019-08-15T00:00:00+00:00[UTC][u-ca=season]"); + +delete Temporal.PlainDateTime.prototype.season; +delete Temporal.PlainDate.prototype.season; +delete Temporal.PlainYearMonth.prototype.season; +delete Temporal.PlainMonthDay.prototype.season; +delete Temporal.ZonedDateTime.prototype.season; + diff --git a/test/staging/Temporal/UserCalendar/old/calendar-non-trivial-mergefields.js b/test/staging/Temporal/UserCalendar/old/calendar-non-trivial-mergefields.js new file mode 100644 index 0000000000..4a18631e07 --- /dev/null +++ b/test/staging/Temporal/UserCalendar/old/calendar-non-trivial-mergefields.js @@ -0,0 +1,146 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: calendar with nontrivial mergeFields implementation +features: [Temporal] +---*/ + +class CenturyCalendar extends Temporal.Calendar { + constructor() { + super("iso8601"); + } + toString() { + return "century"; + } + century(date) { + var {isoYear} = date.getISOFields(); + return Math.ceil(isoYear / 100); + } + centuryYear(date) { + var {isoYear} = date.getISOFields(); + return isoYear % 100; + } + _validateFields(fields) { + var {year, century, centuryYear} = fields; + if (century === undefined !== (centuryYear === undefined)) { + throw new TypeError("pass either both or neither of century and centuryYear"); + } + if (year === undefined) + return (century - 1) * 100 + centuryYear; + if (century !== undefined) { + var centuryCalculatedYear = (century - 1) * 100 + centuryYear; + if (year !== centuryCalculatedYear) { + throw new RangeError("year must agree with century/centuryYear if both given"); + } + } + return year; + } + dateFromFields(fields, options) { + var isoYear = this._validateFields(fields); + return super.dateFromFields({ + ...fields, + year: isoYear + }, options); + } + yearMonthFromFields(fields, options) { + var isoYear = this._validateFields(fields); + return super.yearMonthFromFields({ + ...fields, + year: isoYear + }, options); + } + monthDayFromFields(fields, options) { + var isoYear = this._validateFields(fields); + return super.monthDayFromFields({ + ...fields, + year: isoYear + }, options); + } + fields(fields) { + fields = fields.slice(); + if (fields.includes("year")) + fields.push("century", "centuryYear"); + return fields; + } + mergeFields(fields, additionalFields) { + var {year, century, centuryYear, ...original} = fields; + var { + year: newYear, + century: newCentury, + centuryYear: newCenturyYear + } = additionalFields; + if (newYear === undefined) { + original.century = century; + original.centuryYear = centuryYear; + } + if (newCentury === undefined && newCenturyYear === undefined) { + original.year === year; + } + return { + ...original, + ...additionalFields + }; + } +} +var calendar = new CenturyCalendar(); +var datetime = new Temporal.PlainDateTime(2019, 9, 15, 0, 0, 0, 0, 0, 0, calendar); +var date = new Temporal.PlainDate(2019, 9, 15, calendar); +var yearmonth = new Temporal.PlainYearMonth(2019, 9, calendar); +var zoned = new Temporal.ZonedDateTime(1568505600000000000n, "UTC", calendar); +var propDesc = { + century: { + get() { + return this.calendar.century(this); + }, + configurable: true + }, + centuryYear: { + get() { + return this.calendar.centuryYear(this); + }, + configurable: true + } +}; +Object.defineProperties(Temporal.PlainDateTime.prototype, propDesc); +Object.defineProperties(Temporal.PlainDate.prototype, propDesc); +Object.defineProperties(Temporal.PlainYearMonth.prototype, propDesc); +Object.defineProperties(Temporal.ZonedDateTime.prototype, propDesc); + +// property getters work +assert.sameValue(datetime.century, 21); +assert.sameValue(datetime.centuryYear, 19); +assert.sameValue(date.century, 21); +assert.sameValue(date.centuryYear, 19); +assert.sameValue(yearmonth.century, 21); +assert.sameValue(yearmonth.centuryYear, 19); +assert.sameValue(zoned.century, 21); +assert.sameValue(zoned.centuryYear, 19); + +// correctly resolves century in with() +assert.sameValue(`${ datetime.with({ century: 20 }) }`, "1919-09-15T00:00:00[u-ca=century]"); +assert.sameValue(`${ date.with({ century: 20 }) }`, "1919-09-15[u-ca=century]"); +assert.sameValue(`${ yearmonth.with({ century: 20 }) }`, "1919-09-01[u-ca=century]"); +assert.sameValue(`${ zoned.with({ century: 20 }) }`, "1919-09-15T00:00:00+00:00[UTC][u-ca=century]"); + +// correctly resolves centuryYear in with() +assert.sameValue(`${ datetime.with({ centuryYear: 5 }) }`, "2005-09-15T00:00:00[u-ca=century]"); +assert.sameValue(`${ date.with({ centuryYear: 5 }) }`, "2005-09-15[u-ca=century]"); +assert.sameValue(`${ yearmonth.with({ centuryYear: 5 }) }`, "2005-09-01[u-ca=century]"); +assert.sameValue(`${ zoned.with({ centuryYear: 5 }) }`, "2005-09-15T00:00:00+00:00[UTC][u-ca=century]"); + +// correctly resolves year in with() +assert.sameValue(`${ datetime.with({ year: 1974 }) }`, "1974-09-15T00:00:00[u-ca=century]"); +assert.sameValue(`${ date.with({ year: 1974 }) }`, "1974-09-15[u-ca=century]"); +assert.sameValue(`${ yearmonth.with({ year: 1974 }) }`, "1974-09-01[u-ca=century]"); +assert.sameValue(`${ zoned.with({ year: 1974 }) }`, "1974-09-15T00:00:00+00:00[UTC][u-ca=century]"); + +delete Temporal.PlainDateTime.prototype.century; +delete Temporal.PlainDateTime.prototype.centuryYear; +delete Temporal.PlainDate.prototype.century; +delete Temporal.PlainDate.prototype.centuryYear; +delete Temporal.PlainYearMonth.prototype.century; +delete Temporal.PlainYearMonth.prototype.centuryYear; +delete Temporal.ZonedDateTime.prototype.century; +delete Temporal.ZonedDateTime.prototype.centuryYear; diff --git a/test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js b/test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js new file mode 100644 index 0000000000..73886177cd --- /dev/null +++ b/test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js @@ -0,0 +1,191 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Trivial protocol implementation +features: [Temporal] +---*/ + +function decimalToISO(year, month, day, overflow = "constrain") { + if (overflow === "constrain") { + if (month < 1) + month = 1; + if (month > 10) + month = 10; + if (day < 1) + day = 1; + if (day > 10) + day = 10; + } else if (overflow === "reject") { + if (month < 1 || month > 10 || day < 1 || day > 10) { + throw new RangeError("invalid value"); + } + } + var days = year * 100 + (month - 1) * 10 + (day - 1); + return new Temporal.PlainDate(1970, 1, 1, "iso8601").add({ days }); +} +function isoToDecimal(date) { + var {isoYear, isoMonth, isoDay} = date.getISOFields(); + var isoDate = new Temporal.PlainDate(isoYear, isoMonth, isoDay); + var {days} = isoDate.since(new Temporal.PlainDate(1970, 1, 1), { largestUnit: "days" }); + var year = Math.floor(days / 100); + days %= 100; + return { + year, + days + }; +} +var obj = { + toString() { + return "decimal"; + }, + dateFromFields(fields, options) { + var { + overflow = "constrain" + } = options ? options : {}; + var {month, monthCode} = fields; + if (month === undefined) + month = +monthCode.slice(1); + var isoDate = decimalToISO(fields.year, month, fields.day, 0, 0, 0, overflow); + return new Temporal.PlainDate(isoDate.year, isoDate.month, isoDate.day, this); + }, + yearMonthFromFields(fields, options) { + var { + overflow = "constrain" + } = options ? options : {}; + var {month, monthCode} = fields; + if (month === undefined) + month = +monthCode.slice(1); + var isoDate = decimalToISO(fields.year, month, 1, 0, 0, 0, overflow); + return new Temporal.PlainYearMonth(isoDate.year, isoDate.month, this, isoDate.day); + }, + monthDayFromFields(fields, options) { + var { + overflow = "constrain" + } = options ? options : {}; + var {month, monthCode} = fields; + if (month === undefined) + month = +monthCode.slice(1); + var isoDate = decimalToISO(0, month, fields.day, 0, 0, 0, overflow); + return new Temporal.PlainMonthDay(isoDate.month, isoDate.day, this, isoDate.year); + }, + year(date) { + return isoToDecimal(date).year; + }, + month(date) { + var {days} = isoToDecimal(date); + return Math.floor(days / 10) + 1; + }, + monthCode(date) { + return `M${ this.month(date).toString().padStart(2, "0") }`; + }, + day(date) { + var {days} = isoToDecimal(date); + return days % 10 + 1; + } +}; +var date = Temporal.PlainDate.from({ + year: 184, + month: 2, + day: 9, + calendar: obj +}); +var dt = Temporal.PlainDateTime.from({ + year: 184, + month: 2, + day: 9, + hour: 12, + calendar: obj +}); +var ym = Temporal.PlainYearMonth.from({ + year: 184, + month: 2, + calendar: obj +}); +var md = Temporal.PlainMonthDay.from({ + monthCode: "M02", + day: 9, + calendar: obj +}); + +// is a calendar +assert.sameValue(typeof obj, "object") + +// .id is not available in from() +assert.throws(RangeError, () => Temporal.Calendar.from("decimal")); +assert.throws(RangeError, () => Temporal.Calendar.from("2020-06-05T09:34-07:00[America/Vancouver][u-ca=decimal]")); + +// Temporal.PlainDate.from() +assert.sameValue(`${ date }`, "2020-06-05[u-ca=decimal]") + +// Temporal.PlainDate fields +assert.sameValue(date.year, 184); +assert.sameValue(date.month, 2); +assert.sameValue(date.day, 9); + +// date.with() +var date2 = date.with({ year: 0 }); +assert.sameValue(date2.year, 0); + +// date.withCalendar() +var date2 = Temporal.PlainDate.from("2020-06-05T12:00"); +assert(date2.withCalendar(obj).equals(date)); + +// Temporal.PlainDateTime.from() +assert.sameValue(`${ dt }`, "2020-06-05T12:00:00[u-ca=decimal]") + +// Temporal.PlainDateTime fields +assert.sameValue(dt.year, 184); +assert.sameValue(dt.month, 2); +assert.sameValue(dt.day, 9); +assert.sameValue(dt.hour, 12); +assert.sameValue(dt.minute, 0); +assert.sameValue(dt.second, 0); +assert.sameValue(dt.millisecond, 0); +assert.sameValue(dt.microsecond, 0); +assert.sameValue(dt.nanosecond, 0); + +// datetime.with() +var dt2 = dt.with({ year: 0 }); +assert.sameValue(dt2.year, 0); + +// datetime.withCalendar() +var dt2 = Temporal.PlainDateTime.from("2020-06-05T12:00"); +assert(dt2.withCalendar(obj).equals(dt)); + +// Temporal.PlainYearMonth.from() +assert.sameValue(`${ ym }`, "2020-05-28[u-ca=decimal]") + +// Temporal.PlainYearMonth fields +assert.sameValue(dt.year, 184); +assert.sameValue(dt.month, 2); + +// yearmonth.with() +var ym2 = ym.with({ year: 0 }); +assert.sameValue(ym2.year, 0); + +// Temporal.PlainMonthDay.from() +assert.sameValue(`${ md }`, "1970-01-19[u-ca=decimal]") + +// Temporal.PlainMonthDay fields +assert.sameValue(md.monthCode, "M02"); +assert.sameValue(md.day, 9); + +// monthday.with() +var md2 = md.with({ monthCode: "M01" }); +assert.sameValue(md2.monthCode, "M01"); + +// timezone.getPlainDateTimeFor() +var tz = Temporal.TimeZone.from("UTC"); +var inst = Temporal.Instant.fromEpochSeconds(0); +var dt = tz.getPlainDateTimeFor(inst, obj); +assert.sameValue(dt.calendar.id, obj.id); + +// Temporal.Now.plainDateTime() +var nowDateTime = Temporal.Now.plainDateTime(obj, "UTC"); +assert.sameValue(nowDateTime.calendar.id, obj.id); + +// Temporal.Now.plainDate() +var nowDate = Temporal.Now.plainDate(obj, "UTC"); +assert.sameValue(nowDate.calendar.id, obj.id); diff --git a/test/staging/Temporal/UserCalendar/old/trivial-subclass.js b/test/staging/Temporal/UserCalendar/old/trivial-subclass.js new file mode 100644 index 0000000000..3cac34d5f1 --- /dev/null +++ b/test/staging/Temporal/UserCalendar/old/trivial-subclass.js @@ -0,0 +1,159 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Trivial subclass +features: [Temporal] +---*/ + +class TwoBasedCalendar extends Temporal.Calendar { + constructor() { + super("iso8601"); + } + toString() { + return "two-based"; + } + dateFromFields(fields, options) { + var {year, month, monthCode, day} = fields; + if (month === undefined) + month = +monthCode.slice(1); + return super.dateFromFields({ + year, + monthCode: `M${ (month - 1).toString().padStart(2, "0") }`, + day + }, options); + } + yearMonthFromFields(fields, options) { + var {year, month, monthCode} = fields; + if (month === undefined) + month = +monthCode.slice(1); + return super.yearMonthFromFields({ + year, + monthCode: `M${ (month - 1).toString().padStart(2, "0") }` + }, options); + } + monthDayFromFields(fields, options) { + var {month, monthCode, day} = fields; + if (month === undefined) + month = +monthCode.slice(1); + return super.monthDayFromFields({ + monthCode: `M${ (month - 1).toString().padStart(2, "0") }`, + day + }, options); + } + month(date) { + return date.getISOFields().isoMonth + 1; + } + monthCode(date) { + return `M${ this.month(date).toString().padStart(2, "0") }`; + } +} +var obj = new TwoBasedCalendar(); +var date = Temporal.PlainDate.from({ + year: 2020, + month: 5, + day: 5, + calendar: obj +}); +var dt = Temporal.PlainDateTime.from({ + year: 2020, + month: 5, + day: 5, + hour: 12, + calendar: obj +}); +var ym = Temporal.PlainYearMonth.from({ + year: 2020, + month: 5, + calendar: obj +}); +var md = Temporal.PlainMonthDay.from({ + monthCode: "M05", + day: 5, + calendar: obj +}); + +// is a calendar +assert.sameValue(typeof obj, "object") + +// .id property +assert.sameValue(obj.id, "two-based") + +// .id is not available in from() +assert.throws(RangeError, () => Temporal.Calendar.from("two-based")); +assert.throws(RangeError, () => Temporal.Calendar.from("2020-06-05T09:34-07:00[America/Vancouver][u-ca=two-based]")); + +// Temporal.PlainDate.from() +assert.sameValue(`${ date }`, "2020-04-05[u-ca=two-based]") + +// Temporal.PlainDate fields +assert.sameValue(date.year, 2020); +assert.sameValue(date.month, 5); +assert.sameValue(date.day, 5); + +// date.with() +var date2 = date.with({ month: 2 }); +assert.sameValue(date2.month, 2); + +// date.withCalendar() +var date2 = Temporal.PlainDate.from("2020-04-05"); +assert(date2.withCalendar(obj).equals(date)); + +// Temporal.PlainDateTime.from() +assert.sameValue(`${ dt }`, "2020-04-05T12:00:00[u-ca=two-based]") + +// Temporal.PlainDateTime fields +assert.sameValue(dt.year, 2020); +assert.sameValue(dt.month, 5); +assert.sameValue(dt.day, 5); +assert.sameValue(dt.hour, 12); +assert.sameValue(dt.minute, 0); +assert.sameValue(dt.second, 0); +assert.sameValue(dt.millisecond, 0); +assert.sameValue(dt.microsecond, 0); +assert.sameValue(dt.nanosecond, 0); + +// datetime.with() +var dt2 = dt.with({ month: 2 }); +assert.sameValue(dt2.month, 2); + +// datetime.withCalendar() +var dt2 = Temporal.PlainDateTime.from("2020-04-05T12:00"); +assert(dt2.withCalendar(obj).equals(dt)); + +// Temporal.PlainYearMonth.from() +assert.sameValue(`${ ym }`, "2020-04-01[u-ca=two-based]") + +// Temporal.PlainYearMonth fields +assert.sameValue(dt.year, 2020); +assert.sameValue(dt.month, 5); + +// yearmonth.with() +var ym2 = ym.with({ month: 2 }); +assert.sameValue(ym2.month, 2); + +// Temporal.PlainMonthDay.from() +assert.sameValue(`${ md }`, "1972-04-05[u-ca=two-based]") + +// Temporal.PlainMonthDay fields +assert.sameValue(md.monthCode, "M05"); +assert.sameValue(md.day, 5); + +// monthday.with() +var md2 = md.with({ monthCode: "M02" }); +assert.sameValue(md2.monthCode, "M02"); + +// timezone.getPlainDateTimeFor() +var tz = Temporal.TimeZone.from("UTC"); +var instant = Temporal.Instant.fromEpochSeconds(0); +var dt = tz.getPlainDateTimeFor(instant, obj); +assert.sameValue(dt.calendar.id, obj.id); + +// Temporal.Now.plainDateTime() +var nowDateTime = Temporal.Now.plainDateTime(obj, "UTC"); +assert.sameValue(nowDateTime.calendar.id, obj.id); + +// Temporal.Now.plainDate() +var nowDate = Temporal.Now.plainDate(obj, "UTC"); +assert.sameValue(nowDate.calendar.id, obj.id); diff --git a/test/staging/Temporal/UserTimezone/old/subminute-offset.js b/test/staging/Temporal/UserTimezone/old/subminute-offset.js new file mode 100644 index 0000000000..eb277f085c --- /dev/null +++ b/test/staging/Temporal/UserTimezone/old/subminute-offset.js @@ -0,0 +1,77 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: sub-minute offset +features: [Temporal] +---*/ + +class SubminuteTimeZone extends Temporal.TimeZone { + constructor() { + super("-00:00:01.111111111"); + } + toString() { + return "Custom/Subminute"; + } + getOffsetNanosecondsFor() { + return -1111111111; + } + getPossibleInstantsFor(dateTime) { + var utc = Temporal.TimeZone.from("UTC"); + var instant = utc.getInstantFor(dateTime); + return [instant.add({ nanoseconds: 1111111111 })]; + } + getNextTransition() { + return null; + } + getPreviousTransition() { + return null; + } +} +var obj = new SubminuteTimeZone(); +var inst = Temporal.Instant.fromEpochNanoseconds(0n); +var dt = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789); + +// is a time zone +assert.sameValue(typeof obj, "object") + +// .id property +assert.sameValue(obj.id, "Custom/Subminute") + +// .id is not available in from() +assert.throws(RangeError, () => Temporal.TimeZone.from("Custom/Subminute")); +assert.throws(RangeError, () => Temporal.TimeZone.from("2020-05-26T16:02:46.251163036-00:00:01.111111111[Custom/Subminute]")); + +// has offset string -00:00:01.111111111 +assert.sameValue(obj.getOffsetStringFor(inst), "-00:00:01.111111111") + +// converts to DateTime +assert.sameValue(`${ obj.getPlainDateTimeFor(inst) }`, "1969-12-31T23:59:58.888888889"); +assert.sameValue(`${ obj.getPlainDateTimeFor(inst, "gregory") }`, "1969-12-31T23:59:58.888888889[u-ca=gregory]"); + +// converts to Instant +assert.sameValue(`${ obj.getInstantFor(dt) }`, "1976-11-18T15:23:31.2345679Z"); + +// converts to string +assert.sameValue(`${ obj }`, obj.id) + +// offset prints with minute precision in instant.toString +assert.sameValue(inst.toString({ timeZone: obj }), "1969-12-31T23:59:58.888888889+00:00") + +// offset prints with minute precision prints in zdt.toString +var zdt = new Temporal.ZonedDateTime(0n, obj); +assert.sameValue(zdt.toString(), "1969-12-31T23:59:58.888888889+00:00[Custom/Subminute]"); + +// has no next transitions +assert.sameValue(obj.getNextTransition(), null) + +// has no previous transitions +assert.sameValue(obj.getPreviousTransition(), null) + +// works in Temporal.Now +assert(Temporal.Now.plainDateTimeISO(obj) instanceof Temporal.PlainDateTime); +assert(Temporal.Now.plainDateTime("gregory", obj) instanceof Temporal.PlainDateTime); +assert(Temporal.Now.plainDateISO(obj) instanceof Temporal.PlainDate); +assert(Temporal.Now.plainDate("gregory", obj) instanceof Temporal.PlainDate); +assert(Temporal.Now.plainTimeISO(obj) instanceof Temporal.PlainTime); diff --git a/test/staging/Temporal/UserTimezone/old/trivial-protocol.js b/test/staging/Temporal/UserTimezone/old/trivial-protocol.js new file mode 100644 index 0000000000..17be9197c1 --- /dev/null +++ b/test/staging/Temporal/UserTimezone/old/trivial-protocol.js @@ -0,0 +1,39 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Trivial protocol implementation +features: [Temporal] +---*/ + +var obj = { + getOffsetNanosecondsFor() { + return 0; + }, + getPossibleInstantsFor(dateTime) { + var {year, month, day, hour, minute, second, millisecond, microsecond, nanosecond} = dateTime; + var dayNum = MakeDay(year, month, day); + var time = MakeTime(hour, minute, second, millisecond, microsecond, nanosecond); + var epochNs = MakeDate(dayNum, time); + return [new Temporal.Instant(epochNs)]; + }, + toString() { + return "Etc/Custom/UTC_Protocol"; + } +}; +var inst = Temporal.Instant.fromEpochNanoseconds(0n); + +// offset prints in instant.toString +assert.sameValue(inst.toString({ timeZone: obj }), "1970-01-01T00:00:00+00:00") + +// prints in zdt.toString +var zdt = new Temporal.ZonedDateTime(0n, obj); +assert.sameValue(zdt.toString(), "1970-01-01T00:00:00+00:00[Etc/Custom/UTC_Protocol]"); + +// works in Temporal.Now +assert(Temporal.Now.plainDateTimeISO(obj) instanceof Temporal.PlainDateTime); +assert(Temporal.Now.plainDateTime("gregory", obj) instanceof Temporal.PlainDateTime); +assert(Temporal.Now.plainDateISO(obj) instanceof Temporal.PlainDate); +assert(Temporal.Now.plainDate("gregory", obj) instanceof Temporal.PlainDate); +assert(Temporal.Now.plainTimeISO(obj) instanceof Temporal.PlainTime); diff --git a/test/staging/Temporal/UserTimezone/old/trivial-subclass.js b/test/staging/Temporal/UserTimezone/old/trivial-subclass.js new file mode 100644 index 0000000000..7086456c70 --- /dev/null +++ b/test/staging/Temporal/UserTimezone/old/trivial-subclass.js @@ -0,0 +1,115 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Trivial subclass +features: [Temporal] +---*/ + +class CustomUTCSubclass extends Temporal.TimeZone { + constructor() { + super("UTC"); + } + toString() { + return "Etc/Custom/UTC_Subclass"; + } + getOffsetNanosecondsFor() { + return 0; + } + getPossibleInstantsFor(dateTime) { + var {year, month, day, hour, minute, second, millisecond, microsecond, nanosecond} = dateTime; + var dayNum = MakeDay(year, month, day); + var time = MakeTime(hour, minute, second, millisecond, microsecond, nanosecond); + var epochNs = MakeDate(dayNum, time); + return [new Temporal.Instant(epochNs)]; + } + getNextTransition() { + return null; + } + getPreviousTransition() { + return null; + } +} + +const nsPerDay = 86400_000_000_000n; +const nsPerMillisecond = 1_000_000n; + +function Day(t) { + return t / nsPerDay; +} + +function MakeDate(day, time) { + return day * nsPerDay + time; +} + +function MakeDay(year, month, day) { + const m = month - 1; + const ym = year + Math.floor(m / 12); + const mn = m % 12; + const t = BigInt(Date.UTC(ym, mn, 1)) * nsPerMillisecond; + return Day(t) + BigInt(day) - 1n; +} + +function MakeTime(h, min, s, ms, µs, ns) { + const MinutesPerHour = 60n; + const SecondsPerMinute = 60n; + const nsPerSecond = 1_000_000_000n; + const nsPerMinute = nsPerSecond * SecondsPerMinute; + const nsPerHour = nsPerMinute * MinutesPerHour; + return ( + BigInt(h) * nsPerHour + + BigInt(min) * nsPerMinute + + BigInt(s) * nsPerSecond + + BigInt(ms) * nsPerMillisecond + + BigInt(µs) * 1000n + + BigInt(ns) + ); +} + +var obj = new CustomUTCSubclass(); +var inst = Temporal.Instant.fromEpochNanoseconds(0n); +var dt = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789); + +// is a time zone +assert.sameValue(typeof obj, "object") + +// .id property +assert.sameValue(obj.id, "Etc/Custom/UTC_Subclass") + +// .id is not available in from() +assert.throws(RangeError, () => Temporal.TimeZone.from("Etc/Custom/UTC_Subclass")); +assert.throws(RangeError, () => Temporal.TimeZone.from("2020-05-26T16:02:46.251163036+00:00[Etc/Custom/UTC_Subclass]")); + +// has offset string +00:00 +assert.sameValue(obj.getOffsetStringFor(inst), "+00:00") + +// converts to DateTime +assert.sameValue(`${ obj.getPlainDateTimeFor(inst) }`, "1970-01-01T00:00:00"); +assert.sameValue(`${ obj.getPlainDateTimeFor(inst, "gregory") }`, "1970-01-01T00:00:00[u-ca=gregory]"); + +// converts to Instant +assert.sameValue(`${ obj.getInstantFor(dt) }`, "1976-11-18T15:23:30.123456789Z"); + +// converts to string +assert.sameValue(`${ obj }`, obj.id) + +// offset prints in instant.toString +assert.sameValue(inst.toString({ timeZone: obj }), "1970-01-01T00:00:00+00:00") + +// prints in zdt.toString +var zdt = new Temporal.ZonedDateTime(0n, obj); +assert.sameValue(zdt.toString(), "1970-01-01T00:00:00+00:00[Etc/Custom/UTC_Subclass]"); + +// has no next transitions +assert.sameValue(obj.getNextTransition(), null) + +// has no previous transitions +assert.sameValue(obj.getPreviousTransition(), null) + +// works in Temporal.Now +assert(Temporal.Now.plainDateTimeISO(obj) instanceof Temporal.PlainDateTime); +assert(Temporal.Now.plainDateTime("gregory", obj) instanceof Temporal.PlainDateTime); +assert(Temporal.Now.plainDateISO(obj) instanceof Temporal.PlainDate); +assert(Temporal.Now.plainDate("gregory", obj) instanceof Temporal.PlainDate); +assert(Temporal.Now.plainTimeISO(obj) instanceof Temporal.PlainTime); diff --git a/test/staging/Temporal/ZonedDateTime/old/add.js b/test/staging/Temporal/ZonedDateTime/old/add.js new file mode 100644 index 0000000000..6190e1b6cb --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/add.js @@ -0,0 +1,50 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.add() +features: [Temporal] +---*/ + +var zdt = Temporal.ZonedDateTime.from("1969-12-25T12:23:45.678901234+00:00[UTC]"); +// cross epoch in ms + var one = zdt.subtract({ + hours: 240, + nanoseconds: 800 + }); + var two = zdt.add({ + hours: 240, + nanoseconds: 800 + }); + var three = two.subtract({ + hours: 480, + nanoseconds: 1600 + }); + var four = one.add({ + hours: 480, + nanoseconds: 1600 + }); +assert.sameValue(`${ one }`, "1969-12-15T12:23:45.678900434+00:00[UTC]"); +assert.sameValue(`${ two }`, "1970-01-04T12:23:45.678902034+00:00[UTC]"); +assert(three.equals(one)); +assert(four.equals(two)); + +// zdt.add(durationObj) +var later = zdt.add(Temporal.Duration.from("PT240H0.000000800S")); +assert.sameValue(`${ later }`, "1970-01-04T12:23:45.678902034+00:00[UTC]"); + +// casts argument +assert.sameValue(`${ zdt.add("PT240H0.000000800S") }`, "1970-01-04T12:23:45.678902034+00:00[UTC]"); +var jan31 = Temporal.ZonedDateTime.from("2020-01-31T15:00-08:00[America/Vancouver]"); + +// constrain when ambiguous result +assert.sameValue(`${ jan31.add({ months: 1 }) }`, "2020-02-29T15:00:00-08:00[America/Vancouver]"); +assert.sameValue(`${ jan31.add({ months: 1 }, { overflow: "constrain" }) }`, "2020-02-29T15:00:00-08:00[America/Vancouver]"); + +// symmetrical with regard to negative durations in the time part +assert.sameValue(`${ jan31.add({ minutes: -30 }) }`, "2020-01-31T14:30:00-08:00[America/Vancouver]"); +assert.sameValue(`${ jan31.add({ seconds: -30 }) }`, "2020-01-31T14:59:30-08:00[America/Vancouver]"); + +// throw when ambiguous result with reject +assert.throws(RangeError, () => jan31.add({ months: 1 }, { overflow: "reject" })); diff --git a/test/staging/Temporal/ZonedDateTime/old/compare.js b/test/staging/Temporal/ZonedDateTime/old/compare.js new file mode 100644 index 0000000000..023d677c9c --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/compare.js @@ -0,0 +1,120 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.compare() +features: [Temporal] +---*/ + +var zdt1 = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]"); +var zdt2 = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102+01:00[Europe/Vienna]"); + +// equal +assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt1), 0) + +// smaller/larger +assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt2), -1) + +// larger/smaller +assert.sameValue(Temporal.ZonedDateTime.compare(zdt2, zdt1), 1) + +// casts first argument +assert.sameValue(Temporal.ZonedDateTime.compare({ + year: 1976, + month: 11, + day: 18, + hour: 15, + timeZone: "Europe/Vienna" +}, zdt2), -1); +assert.sameValue(Temporal.ZonedDateTime.compare("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]", zdt2), -1); + +// casts second argument +assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, { + year: 2019, + month: 10, + day: 29, + hour: 10, + timeZone: "Europe/Vienna" +}), -1); +assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, "2019-10-29T10:46:38.271986102+01:00[Europe/Vienna]"), -1); + +// object must contain at least the required properties +assert.sameValue(Temporal.ZonedDateTime.compare({ + year: 1976, + month: 11, + day: 18, + timeZone: "Europe/Vienna" +}, zdt2), -1); +assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({ + month: 11, + day: 18, + timeZone: "Europe/Vienna" +}, zdt2)); +assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({ + year: 1976, + day: 18, + timeZone: "Europe/Vienna" +}, zdt2)); +assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({ + year: 1976, + month: 11, + timeZone: "Europe/Vienna" +}, zdt2)); +assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({ + year: 1976, + month: 11, + day: 18 +}, zdt2)); +assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({ + years: 1976, + months: 11, + days: 19, + hours: 15, + timeZone: "Europe/Vienna" +}, zdt2)); +assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, { + year: 2019, + month: 10, + day: 29, + timeZone: "Europe/Vienna" +}), -1); +assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, { + month: 10, + day: 29, + timeZone: "Europe/Vienna" +})); +assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, { + year: 2019, + day: 29, + timeZone: "Europe/Vienna" +})); +assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, { + year: 2019, + month: 10, + timeZone: "Europe/Vienna" +})); +assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, { + year: 2019, + month: 10, + day: 29 +})); +assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, { + years: 2019, + months: 10, + days: 29, + hours: 10, + timeZone: "Europe/Vienna" +})); + +// disregards time zone IDs if exact times are equal +assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt1.withTimeZone("Asia/Kolkata")), 0); + +// disregards calendar IDs if exact times and time zones are equal +assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt1.withCalendar("japanese")), 0); + +// compares exact time, not clock time +var clockBefore = Temporal.ZonedDateTime.from("1999-12-31T23:30-08:00[America/Vancouver]"); +var clockAfter = Temporal.ZonedDateTime.from("2000-01-01T01:30-04:00[America/Halifax]"); +assert.sameValue(Temporal.ZonedDateTime.compare(clockBefore, clockAfter), 1); +assert.sameValue(Temporal.PlainDateTime.compare(clockBefore.toPlainDateTime(), clockAfter.toPlainDateTime()), -1); diff --git a/test/staging/Temporal/ZonedDateTime/old/construction-and-properties.js b/test/staging/Temporal/ZonedDateTime/old/construction-and-properties.js new file mode 100644 index 0000000000..fae241a403 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/construction-and-properties.js @@ -0,0 +1,86 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Construction and properties +features: [Temporal] +---*/ + +var tz = new Temporal.TimeZone("America/Los_Angeles"); +var epochMillis = Date.UTC(1976, 10, 18, 15, 23, 30, 123); +var epochNanos = BigInt(epochMillis) * BigInt(1000000) + BigInt(456789); + +// works +var zdt = new Temporal.ZonedDateTime(epochNanos, tz); +assert(zdt instanceof Temporal.ZonedDateTime); +assert.sameValue(typeof zdt, "object"); +assert.sameValue(zdt.toInstant().epochSeconds, Math.floor(Date.UTC(1976, 10, 18, 15, 23, 30, 123) / 1000), "epochSeconds"); +assert.sameValue(zdt.toInstant().epochMilliseconds, Date.UTC(1976, 10, 18, 15, 23, 30, 123), "epochMilliseconds"); + +// Temporal.ZonedDateTime for (1976, 11, 18, 15, 23, 30, 123, 456, 789)" + var zdt = new Temporal.ZonedDateTime(epochNanos, new Temporal.TimeZone("UTC")); +// can be constructed +assert(zdt instanceof Temporal.ZonedDateTime); +assert.sameValue(typeof zdt, "object"); + +assert.sameValue(zdt.year, 1976) +assert.sameValue(zdt.month, 11); +assert.sameValue(zdt.monthCode, "M11"); +assert.sameValue(zdt.day, 18); +assert.sameValue(zdt.hour, 15); +assert.sameValue(zdt.minute, 23); +assert.sameValue(zdt.second, 30); +assert.sameValue(zdt.millisecond, 123); +assert.sameValue(zdt.microsecond, 456); +assert.sameValue(zdt.nanosecond, 789); +assert.sameValue(zdt.epochSeconds, 217178610); +assert.sameValue(zdt.epochMilliseconds, 217178610123); +assert.sameValue(zdt.epochMicroseconds, 217178610123456n); +assert.sameValue(zdt.epochNanoseconds, 217178610123456789n); +assert.sameValue(zdt.dayOfWeek, 4); +assert.sameValue(zdt.dayOfYear, 323); +assert.sameValue(zdt.weekOfYear, 47); +assert.sameValue(zdt.daysInWeek, 7); +assert.sameValue(zdt.daysInMonth, 30); +assert.sameValue(zdt.daysInYear, 366); +assert.sameValue(zdt.monthsInYear, 12); +assert.sameValue(zdt.inLeapYear, true); +assert.sameValue(zdt.offset, "+00:00"); +assert.sameValue(zdt.offsetNanoseconds, 0); +assert.sameValue(`${ zdt }`, "1976-11-18T15:23:30.123456789+00:00[UTC]"); + +// Temporal.ZonedDateTime with non-UTC time zone and non-ISO calendar" +var zdt = new Temporal.ZonedDateTime(epochNanos, Temporal.TimeZone.from("Europe/Vienna"), Temporal.Calendar.from("gregory")); + +// can be constructed" +assert(zdt instanceof Temporal.ZonedDateTime); +assert.sameValue(typeof zdt, "object"); + +assert.sameValue(zdt.era, "ce"); +assert.sameValue(zdt.year, 1976); +assert.sameValue(zdt.month, 11); +assert.sameValue(zdt.monthCode, "M11"); +assert.sameValue(zdt.day, 18); +assert.sameValue(zdt.hour, 16); +assert.sameValue(zdt.minute, 23); +assert.sameValue(zdt.second, 30); +assert.sameValue(zdt.millisecond, 123); +assert.sameValue(zdt.microsecond, 456); +assert.sameValue(zdt.nanosecond, 789); +assert.sameValue(zdt.epochSeconds, 217178610); +assert.sameValue(zdt.epochMilliseconds, 217178610123); +assert.sameValue(zdt.epochMicroseconds, 217178610123456n); +assert.sameValue(zdt.epochNanoseconds, 217178610123456789n); +assert.sameValue(zdt.dayOfWeek, 4); +assert.sameValue(zdt.dayOfYear, 323); +assert.sameValue(zdt.weekOfYear, 47); +assert.sameValue(zdt.daysInWeek, 7); +assert.sameValue(zdt.daysInMonth, 30); +assert.sameValue(zdt.daysInYear, 366); +assert.sameValue(zdt.monthsInYear, 12); +assert.sameValue(zdt.inLeapYear, true); +assert.sameValue(zdt.offset, "+01:00"); +assert.sameValue(zdt.offsetNanoseconds, 3600000000000); +assert.sameValue(`${ zdt }`, "1976-11-18T16:23:30.123456789+01:00[Europe/Vienna][u-ca=gregory]"); + diff --git a/test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js b/test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js new file mode 100644 index 0000000000..c8cc2f9261 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js @@ -0,0 +1,23 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: hours overflow +features: [Temporal] +---*/ + + +// subtract result +var later = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102-03:00[America/Santiago]"); +var earlier = later.subtract({ hours: 12 }); +assert.sameValue(`${ earlier }`, "2019-10-28T22:46:38.271986102-03:00[America/Santiago]"); + +// add result +var earlier = Temporal.ZonedDateTime.from("2020-05-31T23:12:38.271986102-04:00[America/Santiago]"); +var later = earlier.add({ hours: 2 }); +assert.sameValue(`${ later }`, "2020-06-01T01:12:38.271986102-04:00[America/Santiago]"); + +// symmetrical with regard to negative durations +assert.sameValue(`${ Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102-03:00[America/Santiago]").add({ hours: -12 }) }`, "2019-10-28T22:46:38.271986102-03:00[America/Santiago]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("2020-05-31T23:12:38.271986102-04:00[America/Santiago]").subtract({ hours: -2 }) }`, "2020-06-01T01:12:38.271986102-04:00[America/Santiago]"); diff --git a/test/staging/Temporal/ZonedDateTime/old/dst-math.js b/test/staging/Temporal/ZonedDateTime/old/dst-math.js new file mode 100644 index 0000000000..07eca2e1d6 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/dst-math.js @@ -0,0 +1,290 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: math around DST +features: [Temporal] +---*/ + +var tz = new Temporal.TimeZone("America/Los_Angeles"); +var hourBeforeDstStart = new Temporal.PlainDateTime(2020, 3, 8, 1).toZonedDateTime(tz); +var dayBeforeDstStart = new Temporal.PlainDateTime(2020, 3, 7, 2, 30).toZonedDateTime(tz); + +// add 1 hour to get to DST start +var added = hourBeforeDstStart.add({ hours: 1 }); +assert.sameValue(added.hour, 3); +var diff = hourBeforeDstStart.until(added, { largestUnit: "hours" }); +assert.sameValue(`${ diff }`, "PT1H"); +assert.sameValue(`${ diff }`, `${ added.since(hourBeforeDstStart, { largestUnit: "hours" }) }`); +var undo = added.subtract(diff); +assert.sameValue(`${ undo }`, `${ hourBeforeDstStart }`); + +// add 2 hours to get to DST start +1 +var added = hourBeforeDstStart.add({ hours: 2 }); +assert.sameValue(added.hour, 4); +var diff = hourBeforeDstStart.until(added, { largestUnit: "hours" }); +assert.sameValue(`${ diff }`, "PT2H"); +assert.sameValue(`${ diff }`, `${ added.since(hourBeforeDstStart, { largestUnit: "hours" }) }`); +var undo = added.subtract(diff); +assert.sameValue(`${ undo }`, `${ hourBeforeDstStart }`); + +// add 1.5 hours to get to 0.5 hours after DST start +var added = hourBeforeDstStart.add({ + hours: 1, + minutes: 30 +}); +assert.sameValue(added.hour, 3); +assert.sameValue(added.minute, 30); +var diff = hourBeforeDstStart.until(added, { largestUnit: "hours" }); +assert.sameValue(`${ diff }`, "PT1H30M"); +assert.sameValue(`${ diff }`, `${ added.since(hourBeforeDstStart, { largestUnit: "hours" }) }`); +var undo = added.subtract(diff); +assert.sameValue(`${ undo }`, `${ hourBeforeDstStart }`); + +// Samoa date line change (add): 10:00PM 29 Dec 2011 -> 11:00PM 31 Dec 2011 +var timeZone = Temporal.TimeZone.from("Pacific/Apia"); +var dayBeforeSamoaDateLineChangeAbs = timeZone.getInstantFor(new Temporal.PlainDateTime(2011, 12, 29, 22)); +var start = dayBeforeSamoaDateLineChangeAbs.toZonedDateTimeISO(timeZone); +var added = start.add({ + days: 1, + hours: 1 +}); +assert.sameValue(added.day, 31); +assert.sameValue(added.hour, 23); +assert.sameValue(added.minute, 0); +var diff = start.until(added, { largestUnit: "days" }); +assert.sameValue(`${ diff }`, "P2DT1H"); +var undo = added.subtract(diff); +assert.sameValue(`${ undo }`, `${ start }`); + +// Samoa date line change (subtract): 11:00PM 31 Dec 2011 -> 10:00PM 29 Dec 2011 +var timeZone = Temporal.TimeZone.from("Pacific/Apia"); +var dayAfterSamoaDateLineChangeAbs = timeZone.getInstantFor(new Temporal.PlainDateTime(2011, 12, 31, 23)); +var start = dayAfterSamoaDateLineChangeAbs.toZonedDateTimeISO(timeZone); +var skipped = start.subtract({ + days: 1, + hours: 1 +}); +assert.sameValue(skipped.day, 31); +assert.sameValue(skipped.hour, 22); +assert.sameValue(skipped.minute, 0); +var end = start.subtract({ + days: 2, + hours: 1 +}); +assert.sameValue(end.day, 29); +assert.sameValue(end.hour, 22); +assert.sameValue(end.minute, 0); +var diff = end.since(start, { largestUnit: "days" }); +assert.sameValue(`${ diff }`, "-P2DT1H"); +var undo = start.add(diff); +assert.sameValue(`${ undo }`, `${ end }`); + +// 3:30 day before DST start -> 3:30 day of DST start +var start = dayBeforeDstStart.add({ hours: 1 }); +var added = start.add({ days: 1 }); +assert.sameValue(added.day, 8); +assert.sameValue(added.hour, 3); +assert.sameValue(added.minute, 30); +var diff = start.until(added, { largestUnit: "days" }); +assert.sameValue(`${ diff }`, "P1D"); +var undo = added.subtract(diff); +assert.sameValue(`${ undo }`, `${ start }`); + +// 2:30 day before DST start -> 3:30 day of DST start +var added = dayBeforeDstStart.add({ days: 1 }); +assert.sameValue(added.day, 8); +assert.sameValue(added.hour, 3); +assert.sameValue(added.minute, 30); +var diff = dayBeforeDstStart.until(added, { largestUnit: "days" }); +assert.sameValue(`${ diff }`, "P1D"); +var undo = dayBeforeDstStart.add(diff); +assert.sameValue(`${ undo }`, `${ added }`); + +// 1:30 day DST starts -> 4:30 day DST starts +var start = dayBeforeDstStart.add({ hours: 23 }); +var added = start.add({ hours: 2 }); +assert.sameValue(added.day, 8); +assert.sameValue(added.hour, 4); +assert.sameValue(added.minute, 30); +var diff = start.until(added, { largestUnit: "days" }); +assert.sameValue(`${ diff }`, "PT2H"); +var undo = added.subtract(diff); +assert.sameValue(`${ undo }`, `${ start }`); + +// 2:00 day before DST starts -> 3:00 day DST starts +var start = hourBeforeDstStart.subtract({ days: 1 }).add({ hours: 1 }); +var added = start.add({ days: 1 }); +assert.sameValue(added.day, 8); +assert.sameValue(added.hour, 3); +assert.sameValue(added.minute, 0); +var diff = start.until(added, { largestUnit: "days" }); +assert.sameValue(`${ diff }`, "P1D"); +var undo = start.add(diff); +assert.sameValue(`${ undo }`, `${ added }`); + +// 1:00AM day DST starts -> (add 24 hours) -> 2:00AM day after DST starts +var start = hourBeforeDstStart; +var added = start.add({ hours: 24 }); +assert.sameValue(added.day, 9); +assert.sameValue(added.hour, 2); +assert.sameValue(added.minute, 0); +var diff = start.until(added, { largestUnit: "days" }); +assert.sameValue(`${ diff }`, "P1DT1H"); +var undo = added.subtract(diff); +assert.sameValue(`${ undo }`, `${ start }`); + +// 12:00AM day DST starts -> (add 24 hours) -> 1:00AM day after DST starts +var start = hourBeforeDstStart.subtract({ hours: 1 }); +var added = start.add({ hours: 24 }); +assert.sameValue(added.day, 9); +assert.sameValue(added.hour, 1); +assert.sameValue(added.minute, 0); +var diff = start.until(added, { largestUnit: "days" }); +assert.sameValue(`${ diff }`, "P1DT1H"); +var undo = added.subtract(diff); +assert.sameValue(`${ undo }`, `${ start }`); + +// Difference can return day length > 24 hours +var start = Temporal.ZonedDateTime.from("2020-10-30T01:45-07:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-11-02T01:15-08:00[America/Los_Angeles]"); +var diff = start.until(end, { largestUnit: "days" }); +assert.sameValue(`${ diff }`, "P2DT24H30M"); +var undo = start.add(diff); +assert.sameValue(`${ undo }`, `${ end }`); + +// Difference rounding (nearest day) is DST-aware +var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]"); +var diff = start.until(end, { + smallestUnit: "days", + roundingMode: "halfExpand" +}); +assert.sameValue(`${ diff }`, "-P3D"); + +// Difference rounding (ceil day) is DST-aware +var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]"); +var diff = start.until(end, { + smallestUnit: "days", + roundingMode: "ceil" +}); +assert.sameValue(`${ diff }`, "-P2D"); + +// Difference rounding (trunc day) is DST-aware +var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]"); +var diff = start.until(end, { + smallestUnit: "days", + roundingMode: "trunc" +}); +assert.sameValue(`${ diff }`, "-P2D"); + +// Difference rounding (floor day) is DST-aware +var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]"); +var diff = start.until(end, { + smallestUnit: "days", + roundingMode: "floor" +}); +assert.sameValue(`${ diff }`, "-P3D"); + +// Difference rounding (nearest hour) is DST-aware +var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]"); +var diff = start.until(end, { + largestUnit: "days", + smallestUnit: "hours", + roundingMode: "halfExpand" +}); +assert.sameValue(`${ diff }`, "-P2DT12H"); + +// Difference rounding (ceil hour) is DST-aware +var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]"); +var diff = start.until(end, { + largestUnit: "days", + smallestUnit: "hours", + roundingMode: "ceil" +}); +assert.sameValue(`${ diff }`, "-P2DT12H"); + +// Difference rounding (trunc hour) is DST-aware +var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]"); +var diff = start.until(end, { + largestUnit: "days", + smallestUnit: "hours", + roundingMode: "trunc" +}); +assert.sameValue(`${ diff }`, "-P2DT12H"); + +// Difference rounding (floor hour) is DST-aware +var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]"); +var diff = start.until(end, { + largestUnit: "days", + smallestUnit: "hours", + roundingMode: "floor" +}); +assert.sameValue(`${ diff }`, "-P2DT13H"); + +// Difference when date portion ends inside a DST-skipped period +var start = Temporal.ZonedDateTime.from("2020-03-07T02:30-08:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-03-08T03:15-07:00[America/Los_Angeles]"); +var diff = start.until(end, { largestUnit: "days" }); +assert.sameValue(`${ diff }`, "PT23H45M"); + +// Difference when date portion ends inside day skipped by Samoa's 24hr 2011 transition +var end = Temporal.ZonedDateTime.from("2011-12-31T05:00+14:00[Pacific/Apia]"); +var start = Temporal.ZonedDateTime.from("2011-12-28T10:00-10:00[Pacific/Apia]"); +var diff = start.until(end, { largestUnit: "days" }); +assert.sameValue(`${ diff }`, "P1DT19H"); + +// Rounding up to hours causes one more day of overflow (positive) +var start = Temporal.ZonedDateTime.from("2020-01-01T00:00-08:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-01-03T23:59-08:00[America/Los_Angeles]"); +var diff = start.until(end, { + largestUnit: "days", + smallestUnit: "hours", + roundingMode: "halfExpand" +}); +assert.sameValue(`${ diff }`, "P3D"); + +// Rounding up to hours causes one more day of overflow (negative) +var start = Temporal.ZonedDateTime.from("2020-01-01T00:00-08:00[America/Los_Angeles]"); +var end = Temporal.ZonedDateTime.from("2020-01-03T23:59-08:00[America/Los_Angeles]"); +var diff = end.until(start, { + largestUnit: "days", + smallestUnit: "hours", + roundingMode: "halfExpand" +}); +assert.sameValue(`${ diff }`, "-P3D"); + +// addition and difference work near DST start +var stepsPerHour = 2; +var minutesPerStep = 60 / stepsPerHour; +var hoursUntilEnd = 26; +var startHourRange = 3; +for (var i = 0; i < startHourRange * stepsPerHour; i++) { + var start = hourBeforeDstStart.add({ minutes: minutesPerStep * i }); + for (var j = 0; j < hoursUntilEnd * stepsPerHour; j++) { + var end = start.add({ minutes: j * minutesPerStep }); + var diff = start.until(end, { largestUnit: "days" }); + var expectedMinutes = minutesPerStep * (j % stepsPerHour); + assert.sameValue(diff.minutes, expectedMinutes); + var diff60 = Math.floor(j / stepsPerHour); + if (i >= stepsPerHour) { + var expectedDays = diff60 < 24 ? 0 : diff60 < 48 ? 1 : 2; + var expectedHours = diff60 < 24 ? diff60 : diff60 < 48 ? diff60 - 24 : diff60 - 48; + assert.sameValue(diff.hours, expectedHours); + assert.sameValue(diff.days, expectedDays); + } else { + var expectedDays = diff60 < 23 ? 0 : diff60 < 47 ? 1 : 2; + var expectedHours = diff60 < 23 ? diff60 : diff60 < 47 ? diff60 - 23 : diff60 - 47; + assert.sameValue(diff.hours, expectedHours); + assert.sameValue(diff.days, expectedDays); + } + } +} diff --git a/test/staging/Temporal/ZonedDateTime/old/dst-properties.js b/test/staging/Temporal/ZonedDateTime/old/dst-properties.js new file mode 100644 index 0000000000..504b4c12e0 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/dst-properties.js @@ -0,0 +1,57 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: properties around DST +features: [Temporal] +---*/ + +var tz = new Temporal.TimeZone("America/Los_Angeles"); +var hourBeforeDstStart = new Temporal.PlainDateTime(2020, 3, 8, 1).toZonedDateTime(tz); +var dayBeforeDstStart = new Temporal.PlainDateTime(2020, 3, 7, 2, 30).toZonedDateTime(tz); + +// hoursInDay works with DST start +assert.sameValue(hourBeforeDstStart.hoursInDay, 23); + +// hoursInDay works with non-DST days +assert.sameValue(dayBeforeDstStart.hoursInDay, 24); + +// hoursInDay works with DST end +var dstEnd = Temporal.ZonedDateTime.from("2020-11-01T01:00-08:00[America/Los_Angeles]"); +assert.sameValue(dstEnd.hoursInDay, 25); + +// hoursInDay works with non-hour DST change +var zdt1 = Temporal.ZonedDateTime.from("2020-10-04T12:00[Australia/Lord_Howe]"); +assert.sameValue(zdt1.hoursInDay, 23.5); +var zdt2 = Temporal.ZonedDateTime.from("2020-04-05T12:00[Australia/Lord_Howe]"); +assert.sameValue(zdt2.hoursInDay, 24.5); + +// hoursInDay works with non-half-hour DST change +var zdt = Temporal.ZonedDateTime.from("1933-01-01T12:00[Asia/Singapore]"); +assert(Math.abs(zdt.hoursInDay - 23.666666666666668) < Number.EPSILON); + +// hoursInDay works when day starts at 1:00 due to DST start at midnight +var zdt = Temporal.ZonedDateTime.from("2015-10-18T12:00:00-02:00[America/Sao_Paulo]"); +assert.sameValue(zdt.hoursInDay, 23); + +// startOfDay works +var start = dayBeforeDstStart.startOfDay(); +assert.sameValue(`${ start.toPlainDate() }`, `${ dayBeforeDstStart.toPlainDate() }`); +assert.sameValue(`${ start.toPlainTime() }`, "00:00:00"); + +// startOfDay works when day starts at 1:00 due to DST start at midnight +var zdt = Temporal.ZonedDateTime.from("2015-10-18T12:00:00-02:00[America/Sao_Paulo]"); +assert.sameValue(`${ zdt.startOfDay().toPlainTime() }`, "01:00:00"); +var dayAfterSamoaDateLineChange = Temporal.ZonedDateTime.from("2011-12-31T22:00+14:00[Pacific/Apia]"); +var dayBeforeSamoaDateLineChange = Temporal.ZonedDateTime.from("2011-12-29T22:00-10:00[Pacific/Apia]"); + +// startOfDay works after Samoa date line change +var start = dayAfterSamoaDateLineChange.startOfDay(); +assert.sameValue(`${ start.toPlainTime() }`, "00:00:00"); + +// hoursInDay works after Samoa date line change +assert.sameValue(dayAfterSamoaDateLineChange.hoursInDay, 24); + +// hoursInDay works before Samoa date line change +assert.sameValue(dayBeforeSamoaDateLineChange.hoursInDay, 24); diff --git a/test/staging/Temporal/ZonedDateTime/old/equals.js b/test/staging/Temporal/ZonedDateTime/old/equals.js new file mode 100644 index 0000000000..8f88c5f164 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/equals.js @@ -0,0 +1,75 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.equals() +features: [Temporal] +---*/ + +var tz = Temporal.TimeZone.from("America/New_York"); +var cal = Temporal.Calendar.from("gregory"); +var zdt = new Temporal.ZonedDateTime(0n, tz, cal); + +// constructed from equivalent parameters are equal +var zdt2 = Temporal.ZonedDateTime.from("1969-12-31T19:00-05:00[America/New_York][u-ca=gregory]"); +assert(zdt.equals(zdt2)); +assert(zdt2.equals(zdt)); + +// different instant not equal +var zdt2 = new Temporal.ZonedDateTime(1n, tz, cal); +assert(!zdt.equals(zdt2)); + +// different time zone not equal +var zdt2 = new Temporal.ZonedDateTime(0n, "America/Chicago", cal); +assert(!zdt.equals(zdt2)); + +// different calendar not equal +var zdt2 = new Temporal.ZonedDateTime(0n, tz, "iso8601"); +assert(!zdt.equals(zdt2)); + +// casts its argument +assert(zdt.equals("1969-12-31T19:00-05:00[America/New_York][u-ca=gregory]")); +assert(zdt.equals({ + year: 1969, + month: 12, + day: 31, + hour: 19, + timeZone: "America/New_York", + calendar: "gregory" +})); + +// at least the required properties must be present +assert(!zdt.equals({ + year: 1969, + month: 12, + day: 31, + timeZone: "America/New_York" +})); +assert.throws(TypeError, () => zdt.equals({ + month: 12, + day: 31, + timeZone: "America/New_York" +})); +assert.throws(TypeError, () => zdt.equals({ + year: 1969, + day: 31, + timeZone: "America/New_York" +})); +assert.throws(TypeError, () => zdt.equals({ + year: 1969, + month: 12, + timeZone: "America/New_York" +})); +assert.throws(TypeError, () => zdt.equals({ + year: 1969, + month: 12, + day: 31 +})); +assert.throws(TypeError, () => zdt.equals({ + years: 1969, + months: 12, + days: 31, + timeZone: "America/New_York", + calendarName: "gregory" +})); diff --git a/test/staging/Temporal/ZonedDateTime/old/order-of-operations.js b/test/staging/Temporal/ZonedDateTime/old/order-of-operations.js new file mode 100644 index 0000000000..c1b7230ae3 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/order-of-operations.js @@ -0,0 +1,79 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: math order of operations and options +features: [Temporal] +---*/ + +var breakoutUnits = (op, zdt, d, options) => zdt[op]({ years: d.years }, options)[op]({ months: d.months }, options)[op]({ weeks: d.weeks }, options)[op]({ days: d.days }, options)[op]({ + hours: d.hours, + minutes: d.minutes, + seconds: d.seconds, + milliseconds: d.milliseconds, + microseconds: d.microseconds, + nanoseconds: d.nanoseconds +}, options); + +// order of operations: add / none +var zdt = Temporal.ZonedDateTime.from("2020-01-31T00:00-08:00[America/Los_Angeles]"); +var d = Temporal.Duration.from({ + months: 1, + days: 1 +}); +var options = undefined; +var result = zdt.add(d, options); +assert.sameValue(result.toString(), "2020-03-01T00:00:00-08:00[America/Los_Angeles]"); +assert.sameValue(breakoutUnits("add", zdt, d, options).toString(), result.toString()); + +// order of operations: add / constrain +var zdt = Temporal.ZonedDateTime.from("2020-01-31T00:00-08:00[America/Los_Angeles]"); +var d = Temporal.Duration.from({ + months: 1, + days: 1 +}); +var options = { overflow: "constrain" }; +var result = zdt.add(d, options); +assert.sameValue(result.toString(), "2020-03-01T00:00:00-08:00[America/Los_Angeles]"); +assert.sameValue(breakoutUnits("add", zdt, d, options).toString(), result.toString()); + +// order of operations: add / reject +var zdt = Temporal.ZonedDateTime.from("2020-01-31T00:00-08:00[America/Los_Angeles]"); +var d = Temporal.Duration.from({ + months: 1, + days: 1 +}); +var options = { overflow: "reject" }; +assert.throws(RangeError, () => zdt.add(d, options)); + +// order of operations: subtract / none +var zdt = Temporal.ZonedDateTime.from("2020-03-31T00:00-07:00[America/Los_Angeles]"); +var d = Temporal.Duration.from({ + months: 1, + days: 1 +}); +var options = undefined; +var result = zdt.subtract(d, options); +assert.sameValue(result.toString(), "2020-02-28T00:00:00-08:00[America/Los_Angeles]"); +assert.sameValue(breakoutUnits("subtract", zdt, d, options).toString(), result.toString()); + +// order of operations: subtract / constrain +var zdt = Temporal.ZonedDateTime.from("2020-03-31T00:00-07:00[America/Los_Angeles]"); +var d = Temporal.Duration.from({ + months: 1, + days: 1 +}); +var options = { overflow: "constrain" }; +var result = zdt.subtract(d, options); +assert.sameValue(result.toString(), "2020-02-28T00:00:00-08:00[America/Los_Angeles]"); +assert.sameValue(breakoutUnits("subtract", zdt, d, options).toString(), result.toString()); + +// order of operations: subtract / reject +var zdt = Temporal.ZonedDateTime.from("2020-03-31T00:00-07:00[America/Los_Angeles]"); +var d = Temporal.Duration.from({ + months: 1, + days: 1 +}); +var options = { overflow: "reject" }; +assert.throws(RangeError, () => zdt.subtract(d, options)); diff --git a/test/staging/Temporal/ZonedDateTime/old/property-bags.js b/test/staging/Temporal/ZonedDateTime/old/property-bags.js new file mode 100644 index 0000000000..b319f7f87b --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/property-bags.js @@ -0,0 +1,282 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: property bags +features: [Temporal] +---*/ + +var lagos = Temporal.TimeZone.from("Africa/Lagos"); + +// can be constructed with monthCode and without month +assert.sameValue(`${ Temporal.ZonedDateTime.from({ + year: 1976, + monthCode: "M11", + day: 18, + timeZone: lagos +}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]"); + +// can be constructed with month and without monthCode +assert.sameValue(`${ Temporal.ZonedDateTime.from({ + year: 1976, + month: 11, + day: 18, + timeZone: lagos +}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]"); + +// month and monthCode must agree +assert.throws(RangeError, () => Temporal.ZonedDateTime.from({ + year: 1976, + month: 11, + monthCode: "M12", + day: 18, + timeZone: lagos +})); + +// Temporal.ZonedDateTime.from({}) throws +assert.throws(TypeError, () => Temporal.ZonedDateTime.from({})) + +// Temporal.ZonedDateTime.from(required prop undefined) throws +assert.throws(TypeError, () => Temporal.ZonedDateTime.from({ + year: 1976, + month: undefined, + monthCode: undefined, + day: 18, + timeZone: lagos +})) + +// options may be a function object +assert.sameValue(`${ Temporal.ZonedDateTime.from({ + year: 1976, + month: 11, + day: 18, + timeZone: lagos +}, () => { +}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]"); + +// object must contain at least the required correctly-spelled properties +assert.throws(TypeError, () => Temporal.ZonedDateTime.from({ + years: 1976, + months: 11, + days: 18, + timeZone: lagos +})); + +// incorrectly-spelled properties are ignored +assert.sameValue(`${ Temporal.ZonedDateTime.from({ + year: 1976, + month: 11, + day: 18, + timeZone: lagos, + hours: 12 +}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]"); + +// casts offset property +var zdt = Temporal.ZonedDateTime.from({ + year: 1976, + month: 11, + day: 18, + offset: -1030, + timeZone: Temporal.TimeZone.from("-10:30") +}); +assert.sameValue(`${ zdt }`, "1976-11-18T00:00:00-10:30[-10:30]"); + +// overflow options +var bad = { + year: 2019, + month: 1, + day: 32, + timeZone: lagos +}; +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(bad, { overflow: "reject" })); +assert.sameValue(`${ Temporal.ZonedDateTime.from(bad) }`, "2019-01-31T00:00:00+01:00[Africa/Lagos]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(bad, { overflow: "constrain" }) }`, "2019-01-31T00:00:00+01:00[Africa/Lagos]"); + +// Offset options + +// { offset: 'reject' } throws if offset does not match offset time zone +var obj = { + year: 2020, + month: 3, + day: 8, + hour: 1, + offset: "-04:00", + timeZone: "-08:00" +}; +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj)); +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { offset: "reject" })); + +// { offset: 'reject' } throws if offset does not match IANA time zone +var obj = { + year: 2020, + month: 3, + day: 8, + hour: 1, + offset: "-04:00", + timeZone: "America/Chicago" +}; +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj)); +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { offset: "reject" })); + +var cali = Temporal.TimeZone.from("America/Los_Angeles"); +var date = { +year: 2020, +month: 11, +day: 1, +timeZone: cali +}; +// { offset: 'prefer' } if offset matches time zone (first 1:30 when DST ends) +var obj = { + ...date, + hour: 1, + minute: 30, + offset: "-07:00" +}; +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset: "prefer" }) }`, "2020-11-01T01:30:00-07:00[America/Los_Angeles]"); + +// { offset: 'prefer' } if offset matches time zone (second 1:30 when DST ends) +var obj = { + ...date, + hour: 1, + minute: 30, + offset: "-08:00" +}; +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset: "prefer" }) }`, "2020-11-01T01:30:00-08:00[America/Los_Angeles]"); + +// { offset: 'prefer' } if offset does not match time zone" +var obj = { + ...date, + hour: 4, + offset: "-07:00" +}; +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset: "prefer" }) }`, "2020-11-01T04:00:00-08:00[America/Los_Angeles]"); + +// { offset: 'ignore' } uses time zone only +var obj = { + ...date, + hour: 4, + offset: "-12:00" +}; +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset: "ignore" }) }`, "2020-11-01T04:00:00-08:00[America/Los_Angeles]"); + +// { offset: 'use' } uses offset only +var obj = { + ...date, + hour: 4, + offset: "-07:00" +}; +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset: "use" }) }`, "2020-11-01T03:00:00-08:00[America/Los_Angeles]"); + +// Disambiguation options + +// plain datetime with multiple instants - Fall DST in Brazil +var brazil = Temporal.TimeZone.from("America/Sao_Paulo"); +var obj = { + year: 2019, + month: 2, + day: 16, + hour: 23, + minute: 45, + timeZone: brazil +}; +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "compatible" }) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "earlier" }) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "later" }) }`, "2019-02-16T23:45:00-03:00[America/Sao_Paulo]"); +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { disambiguation: "reject" })); + +// plain datetime with multiple instants - Spring DST in Los Angeles +var cali = Temporal.TimeZone.from("America/Los_Angeles"); +var obj = { + year: 2020, + month: 3, + day: 8, + hour: 2, + minute: 30, + timeZone: cali +}; +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "compatible" }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "earlier" }) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "later" }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { disambiguation: "reject" })); + +// uses disambiguation if offset is ignored +var cali = Temporal.TimeZone.from("America/Los_Angeles"); +var obj = { + year: 2020, + month: 3, + day: 8, + hour: 2, + minute: 30, + timeZone: cali +}; +var offset = "ignore"; +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { + offset, + disambiguation: "compatible" +}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { + offset, + disambiguation: "earlier" +}) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { + offset, + disambiguation: "later" +}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { disambiguation: "reject" })); + +// uses disambiguation if offset is wrong and option is prefer +var cali = Temporal.TimeZone.from("America/Los_Angeles"); +var obj = { + year: 2020, + month: 3, + day: 8, + hour: 2, + minute: 30, + offset: "-23:59", + timeZone: cali +}; +var offset = "prefer"; +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { + offset, + disambiguation: "compatible" +}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { + offset, + disambiguation: "earlier" +}) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { + offset, + disambiguation: "later" +}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { + offset, + disambiguation: "reject" +})); + +// throw when bad disambiguation +[ + "", + "EARLIER", + "balance", + 3, + null +].forEach(disambiguation => { + assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-11-01T04:00[America/Los_Angeles]", { disambiguation })); +}); + +// sub-minute time zone offsets + +// does not truncate offset property to minutes +var zdt = Temporal.ZonedDateTime.from({ + year: 1971, + month: 1, + day: 1, + hour: 12, + timeZone: "Africa/Monrovia" +}); +assert.sameValue(zdt.offset, "-00:44:30"); diff --git a/test/staging/Temporal/ZonedDateTime/old/reversibility-of-differences.js b/test/staging/Temporal/ZonedDateTime/old/reversibility-of-differences.js new file mode 100644 index 0000000000..eda153a4da --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/reversibility-of-differences.js @@ -0,0 +1,37 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Reversibility of differences +features: [Temporal] +---*/ + +var earlier = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789-03:00[America/Santiago]"); +var later = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102-03:00[America/Santiago]"); +[ + "hours", + "minutes", + "seconds" +].forEach(largestUnit => { + var diff = later.since(earlier, { largestUnit }); +assert.sameValue(`${ earlier.since(later, { largestUnit }) }`, `${ diff.negated() }`); +assert.sameValue(`${ earlier.until(later, { largestUnit }) }`, `${ diff }`); +// difference symmetrical with regard to negative durations + assert(earlier.subtract(diff.negated()).equals(later)); + assert(later.add(diff.negated()).equals(earlier)); + }); +[ + "years", + "months", + "weeks", + "days", + "hours", + "minutes", + "seconds" +].forEach(largestUnit => { + var diff1 = earlier.until(later, { largestUnit }); + var diff2 = later.since(earlier, { largestUnit }); + assert(earlier.add(diff1).equals(later)); + assert(later.subtract(diff2).equals(earlier)); +}); diff --git a/test/staging/Temporal/ZonedDateTime/old/round.js b/test/staging/Temporal/ZonedDateTime/old/round.js new file mode 100644 index 0000000000..42df0c57c4 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/round.js @@ -0,0 +1,348 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.round() +features: [Temporal] +---*/ + +var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]"); + +// throws without parameter +assert.throws(TypeError, () => zdt.round()); + +// throws without required smallestUnit parameter +assert.throws(RangeError, () => zdt.round({})); +assert.throws(RangeError, () => zdt.round({ + roundingIncrement: 1, + roundingMode: "ceil" +})); + +// throws on disallowed or invalid smallestUnit (string param) +[ + "era", + "year", + "month", + "week", + "years", + "months", + "weeks", + "nonsense" +].forEach(smallestUnit => { + assert.throws(RangeError, () => zdt.round(smallestUnit)); +}); +var incrementOneNearest = [ + [ + "day", + "1976-11-19T00:00:00+01:00[Europe/Vienna]" + ], + [ + "hour", + "1976-11-18T15:00:00+01:00[Europe/Vienna]" + ], + [ + "minute", + "1976-11-18T15:24:00+01:00[Europe/Vienna]" + ], + [ + "second", + "1976-11-18T15:23:30+01:00[Europe/Vienna]" + ], + [ + "millisecond", + "1976-11-18T15:23:30.123+01:00[Europe/Vienna]" + ], + [ + "microsecond", + "1976-11-18T15:23:30.123457+01:00[Europe/Vienna]" + ], + [ + "nanosecond", + "1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]" + ] +]; +incrementOneNearest.forEach(([smallestUnit, expected]) => { + assert.sameValue(`${ zdt.round({ + smallestUnit, + roundingMode: "halfExpand" + }) }`, expected); +}); +var incrementOneCeil = [ + [ + "day", + "1976-11-19T00:00:00+01:00[Europe/Vienna]" + ], + [ + "hour", + "1976-11-18T16:00:00+01:00[Europe/Vienna]" + ], + [ + "minute", + "1976-11-18T15:24:00+01:00[Europe/Vienna]" + ], + [ + "second", + "1976-11-18T15:23:31+01:00[Europe/Vienna]" + ], + [ + "millisecond", + "1976-11-18T15:23:30.124+01:00[Europe/Vienna]" + ], + [ + "microsecond", + "1976-11-18T15:23:30.123457+01:00[Europe/Vienna]" + ], + [ + "nanosecond", + "1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]" + ] +]; +incrementOneCeil.forEach(([smallestUnit, expected]) => { + assert.sameValue(`${ zdt.round({ + smallestUnit, + roundingMode: "ceil" + }) }`, expected); +}); +var incrementOneFloor = [ + [ + "day", + "1976-11-18T00:00:00+01:00[Europe/Vienna]" + ], + [ + "hour", + "1976-11-18T15:00:00+01:00[Europe/Vienna]" + ], + [ + "minute", + "1976-11-18T15:23:00+01:00[Europe/Vienna]" + ], + [ + "second", + "1976-11-18T15:23:30+01:00[Europe/Vienna]" + ], + [ + "millisecond", + "1976-11-18T15:23:30.123+01:00[Europe/Vienna]" + ], + [ + "microsecond", + "1976-11-18T15:23:30.123456+01:00[Europe/Vienna]" + ], + [ + "nanosecond", + "1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]" + ] +]; +incrementOneFloor.forEach(([smallestUnit, expected]) => { + assert.sameValue(`${ zdt.round({ + smallestUnit, + roundingMode: "floor" + }) }`, expected); + assert.sameValue(`${ zdt.round({ + smallestUnit, + roundingMode: "trunc" + }) }`, expected); +}); + +// rounds to an increment of hours +assert.sameValue(`${ zdt.round({ + smallestUnit: "hour", + roundingIncrement: 4 +}) }`, "1976-11-18T16:00:00+01:00[Europe/Vienna]"); + +// rounds to an increment of minutes +assert.sameValue(`${ zdt.round({ + smallestUnit: "minute", + roundingIncrement: 15 +}) }`, "1976-11-18T15:30:00+01:00[Europe/Vienna]"); + +// rounds to an increment of seconds +assert.sameValue(`${ zdt.round({ + smallestUnit: "second", + roundingIncrement: 30 +}) }`, "1976-11-18T15:23:30+01:00[Europe/Vienna]"); + +// rounds to an increment of milliseconds +assert.sameValue(`${ zdt.round({ + smallestUnit: "millisecond", + roundingIncrement: 10 +}) }`, "1976-11-18T15:23:30.12+01:00[Europe/Vienna]"); + +// rounds to an increment of microseconds +assert.sameValue(`${ zdt.round({ + smallestUnit: "microsecond", + roundingIncrement: 10 +}) }`, "1976-11-18T15:23:30.12346+01:00[Europe/Vienna]"); + +// rounds to an increment of nanoseconds +assert.sameValue(`${ zdt.round({ + smallestUnit: "nanosecond", + roundingIncrement: 10 +}) }`, "1976-11-18T15:23:30.12345679+01:00[Europe/Vienna]"); + +// 1 day is a valid increment +assert.sameValue(`${ zdt.round({ + smallestUnit: "day", + roundingIncrement: 1 +}) }`, "1976-11-19T00:00:00+01:00[Europe/Vienna]"); + +// valid hour increments divide into 24 +var smallestUnit = "hour"; +[ + 1, + 2, + 3, + 4, + 6, + 8, + 12 +].forEach(roundingIncrement => { + assert(zdt.round({ + smallestUnit, + roundingIncrement + }) instanceof Temporal.ZonedDateTime); +}); +[ + "minute", + "second" +].forEach(smallestUnit => { + // valid minutes/seconds increments divide into 60`, () => { + [ + 1, + 2, + 3, + 4, + 5, + 6, + 10, + 12, + 15, + 20, + 30 + ].forEach(roundingIncrement => { + assert(zdt.round({ + smallestUnit, + roundingIncrement + }) instanceof Temporal.ZonedDateTime); + }); + }); +[ + "millisecond", + "microsecond", + "nanosecond" +].forEach(smallestUnit => { + // valid increments divide into 1000` + [ + 1, + 2, + 4, + 5, + 8, + 10, + 20, + 25, + 40, + 50, + 100, + 125, + 200, + 250, + 500 + ].forEach(roundingIncrement => { + assert(zdt.round({ + smallestUnit, + roundingIncrement + }) instanceof Temporal.ZonedDateTime); + }); + }); + +// throws on increments that do not divide evenly into the next highest +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "day", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "hour", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "minute", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "second", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "millisecond", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "microsecond", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "nanosecond", + roundingIncrement: 29 +})); + +// throws on increments that are equal to the next highest +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "hour", + roundingIncrement: 24 +})); +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "minute", + roundingIncrement: 60 +})); +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "second", + roundingIncrement: 60 +})); +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "millisecond", + roundingIncrement: 1000 +})); +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "microsecond", + roundingIncrement: 1000 +})); +assert.throws(RangeError, () => zdt.round({ + smallestUnit: "nanosecond", + roundingIncrement: 1000 +})); +var bal = Temporal.ZonedDateTime.from("1976-11-18T23:59:59.999999999+01:00[Europe/Vienna]"); +[ + "day", + "hour", + "minute", + "second", + "millisecond", + "microsecond" +].forEach(smallestUnit => { + assert.sameValue(`${ bal.round({ smallestUnit }) }`, "1976-11-19T00:00:00+01:00[Europe/Vienna]"); +}); + +// rounds correctly to a 25-hour day +var roundTo = { smallestUnit: "day" }; +var roundMeDown = Temporal.ZonedDateTime.from("2020-11-01T12:29:59-08:00[America/Vancouver]"); +assert.sameValue(`${ roundMeDown.round(roundTo) }`, "2020-11-01T00:00:00-07:00[America/Vancouver]"); +var roundMeUp = Temporal.ZonedDateTime.from("2020-11-01T12:30:01-08:00[America/Vancouver]"); +assert.sameValue(`${ roundMeUp.round(roundTo) }`, "2020-11-02T00:00:00-08:00[America/Vancouver]"); + +// rounds correctly to a 23-hour day +var roundTo = { smallestUnit: "day" }; +var roundMeDown = Temporal.ZonedDateTime.from("2020-03-08T11:29:59-07:00[America/Vancouver]"); +assert.sameValue(`${ roundMeDown.round(roundTo) }`, "2020-03-08T00:00:00-08:00[America/Vancouver]"); +var roundMeUp = Temporal.ZonedDateTime.from("2020-03-08T11:30:01-07:00[America/Vancouver]"); +assert.sameValue(`${ roundMeUp.round(roundTo) }`, "2020-03-09T00:00:00-07:00[America/Vancouver]"); + +// rounding up to a nonexistent wall-clock time +var almostSkipped = Temporal.ZonedDateTime.from("2018-11-03T23:59:59.999999999-03:00[America/Sao_Paulo]"); +var rounded = almostSkipped.round({ + smallestUnit: "microsecond", + roundingMode: "halfExpand" +}); +assert.sameValue(`${ rounded }`, "2018-11-04T01:00:00-02:00[America/Sao_Paulo]"); +assert.sameValue(rounded.epochNanoseconds - almostSkipped.epochNanoseconds, 1n); diff --git a/test/staging/Temporal/ZonedDateTime/old/since.js b/test/staging/Temporal/ZonedDateTime/old/since.js new file mode 100644 index 0000000000..59b4dc4886 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/since.js @@ -0,0 +1,516 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.since() +features: [Temporal] +---*/ + +var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]"); + +// zdt.since(earlier) === earlier.until(zdt) with default options +var earlier = Temporal.ZonedDateTime.from({ + year: 1966, + month: 3, + day: 3, + hour: 18, + timeZone: "Europe/Vienna" +}); +assert.sameValue(`${ zdt.since(earlier) }`, `${ earlier.until(zdt) }`); + +// casts argument +assert.sameValue(`${ zdt.since({ + year: 2019, + month: 10, + day: 29, + hour: 10, + timeZone: "Europe/Vienna" +}) }`, "-PT376434H36M29.876543211S"); +assert.sameValue(`${ zdt.since("2019-10-29T10:46:38.271986102+01:00[Europe/Vienna]") }`, "-PT376435H23M8.148529313S"); +var feb20 = Temporal.ZonedDateTime.from("2020-02-01T00:00+01:00[Europe/Vienna]"); +var feb21 = Temporal.ZonedDateTime.from("2021-02-01T00:00+01:00[Europe/Vienna]"); + +// defaults to returning hours +assert.sameValue(`${ feb21.since(feb20) }`, "PT8784H"); +assert.sameValue(`${ feb21.since(feb20, { largestUnit: "auto" }) }`, "PT8784H"); +assert.sameValue(`${ feb21.since(feb20, { largestUnit: "hours" }) }`, "PT8784H"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("2021-02-01T00:00:00.000000001+01:00[Europe/Vienna]").since(feb20) }`, "PT8784H0.000000001S"); +assert.sameValue(`${ feb21.since(Temporal.ZonedDateTime.from("2020-02-01T00:00:00.000000001+01:00[Europe/Vienna]")) }`, "PT8783H59M59.999999999S"); + +// can return lower or higher units +assert.sameValue(`${ feb21.since(feb20, { largestUnit: "years" }) }`, "P1Y"); +assert.sameValue(`${ feb21.since(feb20, { largestUnit: "months" }) }`, "P12M"); +assert.sameValue(`${ feb21.since(feb20, { largestUnit: "weeks" }) }`, "P52W2D"); +assert.sameValue(`${ feb21.since(feb20, { largestUnit: "days" }) }`, "P366D"); +assert.sameValue(`${ feb21.since(feb20, { largestUnit: "minutes" }) }`, "PT527040M"); +assert.sameValue(`${ feb21.since(feb20, { largestUnit: "seconds" }) }`, "PT31622400S"); + +// can return subseconds +var later = feb20.add({ + days: 1, + milliseconds: 250, + microseconds: 250, + nanoseconds: 250 +}); +var msDiff = later.since(feb20, { largestUnit: "milliseconds" }); +assert.sameValue(msDiff.seconds, 0); +assert.sameValue(msDiff.milliseconds, 86400250); +assert.sameValue(msDiff.microseconds, 250); +assert.sameValue(msDiff.nanoseconds, 250); +var µsDiff = later.since(feb20, { largestUnit: "microseconds" }); +assert.sameValue(µsDiff.milliseconds, 0); +assert.sameValue(µsDiff.microseconds, 86400250250); +assert.sameValue(µsDiff.nanoseconds, 250); +var nsDiff = later.since(feb20, { largestUnit: "nanoseconds" }); +assert.sameValue(nsDiff.microseconds, 0); +assert.sameValue(nsDiff.nanoseconds, 86400250250250); + +// does not include higher units than necessary +var lastFeb20 = Temporal.ZonedDateTime.from("2020-02-29T00:00+01:00[Europe/Vienna]"); +var lastFeb21 = Temporal.ZonedDateTime.from("2021-02-28T00:00+01:00[Europe/Vienna]"); +assert.sameValue(`${ lastFeb21.since(lastFeb20) }`, "PT8760H"); +assert.sameValue(`${ lastFeb21.since(lastFeb20, { largestUnit: "months" }) }`, "P11M28D"); +assert.sameValue(`${ lastFeb21.since(lastFeb20, { largestUnit: "years" }) }`, "P11M28D"); + +// weeks and months are mutually exclusive +var laterDateTime = zdt.add({ + days: 42, + hours: 3 +}); +var weeksDifference = laterDateTime.since(zdt, { largestUnit: "weeks" }); +assert.notSameValue(weeksDifference.weeks, 0); +assert.sameValue(weeksDifference.months, 0); +var monthsDifference = laterDateTime.since(zdt, { largestUnit: "months" }); +assert.sameValue(monthsDifference.weeks, 0); +assert.notSameValue(monthsDifference.months, 0); + +// no two different calendars +var zdt1 = new Temporal.ZonedDateTime(0n, "UTC"); +var zdt2 = new Temporal.ZonedDateTime(0n, "UTC", Temporal.Calendar.from("japanese")); +assert.throws(RangeError, () => zdt1.since(zdt2)); + +var earlier = Temporal.ZonedDateTime.from('2019-01-08T09:22:36.123456789+01:00[Europe/Vienna]'); +var later = Temporal.ZonedDateTime.from('2021-09-07T14:39:40.987654321+02:00[Europe/Vienna]'); +// assumes a different default for largestUnit if smallestUnit is larger than days +assert.sameValue(`${ later.since(earlier, { + smallestUnit: "years", + roundingMode: "halfExpand" +}) }`, "P3Y"); +assert.sameValue(`${ later.since(earlier, { + smallestUnit: "months", + roundingMode: "halfExpand" +}) }`, "P32M"); +assert.sameValue(`${ later.since(earlier, { + smallestUnit: "weeks", + roundingMode: "halfExpand" +}) }`, "P139W"); +var incrementOneNearest = [ + [ + "years", + "P3Y" + ], + [ + "months", + "P32M" + ], + [ + "weeks", + "P139W" + ], + [ + "days", + "P973D" + ], + [ + "hours", + "PT23356H" + ], + [ + "minutes", + "PT23356H17M" + ], + [ + "seconds", + "PT23356H17M5S" + ], + [ + "milliseconds", + "PT23356H17M4.864S" + ], + [ + "microseconds", + "PT23356H17M4.864198S" + ], + [ + "nanoseconds", + "PT23356H17M4.864197532S" + ] +]; +incrementOneNearest.forEach(([smallestUnit, expected]) => { + var roundingMode = "halfExpand"; + assert.sameValue(`${ later.since(earlier, { + smallestUnit, + roundingMode + }) }`, expected); + assert.sameValue(`${ earlier.since(later, { + smallestUnit, + roundingMode + }) }`, `-${ expected }`); +}); +var incrementOneCeil = [ + [ + "years", + "P3Y", + "-P2Y" + ], + [ + "months", + "P32M", + "-P31M" + ], + [ + "weeks", + "P140W", + "-P139W" + ], + [ + "days", + "P974D", + "-P973D" + ], + [ + "hours", + "PT23357H", + "-PT23356H" + ], + [ + "minutes", + "PT23356H18M", + "-PT23356H17M" + ], + [ + "seconds", + "PT23356H17M5S", + "-PT23356H17M4S" + ], + [ + "milliseconds", + "PT23356H17M4.865S", + "-PT23356H17M4.864S" + ], + [ + "microseconds", + "PT23356H17M4.864198S", + "-PT23356H17M4.864197S" + ], + [ + "nanoseconds", + "PT23356H17M4.864197532S", + "-PT23356H17M4.864197532S" + ] +]; +incrementOneCeil.forEach(([smallestUnit, expectedPositive, expectedNegative]) => { + var roundingMode = "ceil"; + assert.sameValue(`${ later.since(earlier, { + smallestUnit, + roundingMode + }) }`, expectedPositive); + assert.sameValue(`${ earlier.since(later, { + smallestUnit, + roundingMode + }) }`, expectedNegative); +}); +var incrementOneFloor = [ + [ + "years", + "P2Y", + "-P3Y" + ], + [ + "months", + "P31M", + "-P32M" + ], + [ + "weeks", + "P139W", + "-P140W" + ], + [ + "days", + "P973D", + "-P974D" + ], + [ + "hours", + "PT23356H", + "-PT23357H" + ], + [ + "minutes", + "PT23356H17M", + "-PT23356H18M" + ], + [ + "seconds", + "PT23356H17M4S", + "-PT23356H17M5S" + ], + [ + "milliseconds", + "PT23356H17M4.864S", + "-PT23356H17M4.865S" + ], + [ + "microseconds", + "PT23356H17M4.864197S", + "-PT23356H17M4.864198S" + ], + [ + "nanoseconds", + "PT23356H17M4.864197532S", + "-PT23356H17M4.864197532S" + ] +]; +incrementOneFloor.forEach(([smallestUnit, expectedPositive, expectedNegative]) => { + var roundingMode = "floor"; + assert.sameValue(`${ later.since(earlier, { + smallestUnit, + roundingMode + }) }`, expectedPositive); + assert.sameValue(`${ earlier.since(later, { + smallestUnit, + roundingMode + }) }`, expectedNegative); +}); +var incrementOneTrunc = [ + [ + "years", + "P2Y" + ], + [ + "months", + "P31M" + ], + [ + "weeks", + "P139W" + ], + [ + "days", + "P973D" + ], + [ + "hours", + "PT23356H" + ], + [ + "minutes", + "PT23356H17M" + ], + [ + "seconds", + "PT23356H17M4S" + ], + [ + "milliseconds", + "PT23356H17M4.864S" + ], + [ + "microseconds", + "PT23356H17M4.864197S" + ], + [ + "nanoseconds", + "PT23356H17M4.864197532S" + ] +]; +incrementOneTrunc.forEach(([smallestUnit, expected]) => { + var roundingMode = "trunc"; + assert.sameValue(`${ later.since(earlier, { + smallestUnit, + roundingMode + }) }`, expected); + assert.sameValue(`${ earlier.since(later, { + smallestUnit, + roundingMode + }) }`, `-${ expected }`); +}); + +// rounds to an increment of hours +assert.sameValue(`${ later.since(earlier, { + smallestUnit: "hours", + roundingIncrement: 3, + roundingMode: "halfExpand" +}) }`, "PT23355H"); + +// rounds to an increment of minutes +assert.sameValue(`${ later.since(earlier, { + smallestUnit: "minutes", + roundingIncrement: 30, + roundingMode: "halfExpand" +}) }`, "PT23356H30M"); + +// rounds to an increment of seconds +assert.sameValue(`${ later.since(earlier, { + smallestUnit: "seconds", + roundingIncrement: 15, + roundingMode: "halfExpand" +}) }`, "PT23356H17M"); + +// rounds to an increment of milliseconds +assert.sameValue(`${ later.since(earlier, { + smallestUnit: "milliseconds", + roundingIncrement: 10, + roundingMode: "halfExpand" +}) }`, "PT23356H17M4.86S"); + +// rounds to an increment of microseconds +assert.sameValue(`${ later.since(earlier, { + smallestUnit: "microseconds", + roundingIncrement: 10, + roundingMode: "halfExpand" +}) }`, "PT23356H17M4.8642S"); + +// rounds to an increment of nanoseconds +assert.sameValue(`${ later.since(earlier, { + smallestUnit: "nanoseconds", + roundingIncrement: 10, + roundingMode: "halfExpand" +}) }`, "PT23356H17M4.86419753S"); + +// valid hour increments divide into 24 +[ + 1, + 2, + 3, + 4, + 6, + 8, + 12 +].forEach(roundingIncrement => { + var options = { + smallestUnit: "hours", + roundingIncrement + }; + assert(later.since(earlier, options) instanceof Temporal.Duration); +}); +[ + "minutes", + "seconds" +].forEach(smallestUnit => { + [ + 1, + 2, + 3, + 4, + 5, + 6, + 10, + 12, + 15, + 20, + 30 + ].forEach(roundingIncrement => { + var options = { + smallestUnit, + roundingIncrement + }; + assert(later.since(earlier, options) instanceof Temporal.Duration); + }); +}); +[ + "milliseconds", + "microseconds", + "nanoseconds" +].forEach(smallestUnit => { + [ + 1, + 2, + 4, + 5, + 8, + 10, + 20, + 25, + 40, + 50, + 100, + 125, + 200, + 250, + 500 + ].forEach(roundingIncrement => { + var options = { + smallestUnit, + roundingIncrement + }; + assert(later.since(earlier, options) instanceof Temporal.Duration); + }); +}); + +// throws on increments that do not divide evenly into the next highest +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "hours", + roundingIncrement: 11 +})); +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "minutes", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "seconds", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "milliseconds", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "microseconds", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "nanoseconds", + roundingIncrement: 29 +})); + +// throws on increments that are equal to the next highest +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "hours", + roundingIncrement: 24 +})); +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "minutes", + roundingIncrement: 60 +})); +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "seconds", + roundingIncrement: 60 +})); +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "milliseconds", + roundingIncrement: 1000 +})); +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "microseconds", + roundingIncrement: 1000 +})); +assert.throws(RangeError, () => later.since(earlier, { + smallestUnit: "nanoseconds", + roundingIncrement: 1000 +})); + +// rounds relative to the receiver +var dt1 = Temporal.ZonedDateTime.from("2019-01-01T00:00+00:00[UTC]"); +var dt2 = Temporal.ZonedDateTime.from("2020-07-02T00:00+00:00[UTC]"); +assert.sameValue(`${ dt2.since(dt1, { + smallestUnit: "years", + roundingMode: "halfExpand" +}) }`, "P1Y"); +assert.sameValue(`${ dt1.since(dt2, { + smallestUnit: "years", + roundingMode: "halfExpand" +}) }`, "-P2Y"); + diff --git a/test/staging/Temporal/ZonedDateTime/old/string-parsing.js b/test/staging/Temporal/ZonedDateTime/old/string-parsing.js new file mode 100644 index 0000000000..4b5bbcaac5 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/string-parsing.js @@ -0,0 +1,157 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: string parsing +features: [Temporal] +---*/ + +// parses with an IANA zone but no offset (with disambiguation) +var zdt = Temporal.ZonedDateTime.from("2020-03-08T02:30[America/Los_Angeles]", { disambiguation: "earlier" }); +assert.sameValue(zdt.toString(), "2020-03-08T01:30:00-08:00[America/Los_Angeles]"); + +// "Z" means preserve the exact time in the given IANA time zone +var zdt = Temporal.ZonedDateTime.from("2020-03-08T09:00:00Z[America/Los_Angeles]"); +assert.sameValue(zdt.toString(), "2020-03-08T01:00:00-08:00[America/Los_Angeles]"); + +// any number of decimal places +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.1-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.1-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.12-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.123-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.1234-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.1234-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12345-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.12345-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.123456-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.1234567-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.1234567-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12345678-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.12345678-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.123456789-08:00[America/Los_Angeles]"); + +// variant decimal separator +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30,12-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.12-08:00[America/Los_Angeles]"); + +// variant minus sign +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12\u221208:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.12-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("\u2212009999-11-18T15:23:30.12+00:00[UTC]") }`, "-009999-11-18T15:23:30.12+00:00[UTC]"); + +// mixture of basic and extended format +[ + "1976-11-18T152330.1-08:00[America/Los_Angeles]", + "19761118T15:23:30.1-08:00[America/Los_Angeles]", + "1976-11-18T15:23:30.1-0800[America/Los_Angeles]", + "1976-11-18T152330.1-0800[America/Los_Angeles]", + "19761118T15:23:30.1-0800[America/Los_Angeles]", + "19761118T152330.1-08:00[America/Los_Angeles]", + "19761118T152330.1-0800[America/Los_Angeles]", + "+001976-11-18T152330.1-08:00[America/Los_Angeles]", + "+0019761118T15:23:30.1-08:00[America/Los_Angeles]", + "+001976-11-18T15:23:30.1-0800[America/Los_Angeles]", + "+001976-11-18T152330.1-0800[America/Los_Angeles]", + "+0019761118T15:23:30.1-0800[America/Los_Angeles]", + "+0019761118T152330.1-08:00[America/Los_Angeles]", + "+0019761118T152330.1-0800[America/Los_Angeles]" +].forEach(input => assert.sameValue(`${ Temporal.ZonedDateTime.from(input) }`, "1976-11-18T15:23:30.1-08:00[America/Los_Angeles]")); + +// optional parts +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30-08[America/Los_Angeles]") }`, "1976-11-18T15:23:30-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15-08:00[America/Los_Angeles]") }`, "1976-11-18T15:00:00-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("2020-01-01[Asia/Tokyo]") }`, "2020-01-01T00:00:00+09:00[Asia/Tokyo]"); + +// no junk at end of string +assert.throws(RangeError, () => Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789-08:00[America/Los_Angeles]junk")) + +// constrain has no effect on invalid ISO string +assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-13-34T24:60[America/Los_Angeles]", { overflow: "constrain" })); +// Offset options + +// { offset: 'reject' } throws if offset does not match IANA time zone +assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-03-08T01:00-04:00[America/Chicago]")); +assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-03-08T01:00-04:00[America/Chicago]", { offset: "reject" })); + +// { offset: 'prefer' } if offset matches time zone (first 1:30 when DST ends) +var zdt = Temporal.ZonedDateTime.from("2020-11-01T01:30-07:00[America/Los_Angeles]", { offset: "prefer" }); +assert.sameValue(zdt.toString(), "2020-11-01T01:30:00-07:00[America/Los_Angeles]"); + +// { offset: 'prefer' } if offset matches time zone (second 1:30 when DST ends) +var zdt = Temporal.ZonedDateTime.from("2020-11-01T01:30-08:00[America/Los_Angeles]", { offset: "prefer" }); +assert.sameValue(zdt.toString(), "2020-11-01T01:30:00-08:00[America/Los_Angeles]"); + +// { offset: 'prefer' } if offset does not match time zone +var zdt = Temporal.ZonedDateTime.from("2020-11-01T04:00-07:00[America/Los_Angeles]", { offset: "prefer" }); +assert.sameValue(zdt.toString(), "2020-11-01T04:00:00-08:00[America/Los_Angeles]"); + +// { offset: 'ignore' } uses time zone only +var zdt = Temporal.ZonedDateTime.from("2020-11-01T04:00-12:00[America/Los_Angeles]", { offset: "ignore" }); +assert.sameValue(zdt.toString(), "2020-11-01T04:00:00-08:00[America/Los_Angeles]"); + +// { offset: 'use' } uses offset only +var zdt = Temporal.ZonedDateTime.from("2020-11-01T04:00-07:00[America/Los_Angeles]", { offset: "use" }); +assert.sameValue(zdt.toString(), "2020-11-01T03:00:00-08:00[America/Los_Angeles]"); + +// Disambiguation options + +// plain datetime with multiple instants - Fall DST in Brazil +var str = "2019-02-16T23:45[America/Sao_Paulo]"; +assert.sameValue(`${ Temporal.ZonedDateTime.from(str) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "compatible" }) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "earlier" }) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "later" }) }`, "2019-02-16T23:45:00-03:00[America/Sao_Paulo]"); +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, { disambiguation: "reject" })); + +// plain datetime with multiple instants - Spring DST in Los Angeles +var str = "2020-03-08T02:30[America/Los_Angeles]"; +assert.sameValue(`${ Temporal.ZonedDateTime.from(str) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "compatible" }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "earlier" }) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "later" }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, { disambiguation: "reject" })); + +// uses disambiguation if offset is ignored +var str = "2020-03-08T02:30[America/Los_Angeles]"; +var offset = "ignore"; +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { offset }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { + offset, + disambiguation: "compatible" +}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { + offset, + disambiguation: "earlier" +}) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { + offset, + disambiguation: "later" +}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, { + offset, + disambiguation: "reject" +})); + +// uses disambiguation if offset is wrong and option is prefer +var str = "2020-03-08T02:30-23:59[America/Los_Angeles]"; +var offset = "prefer"; +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { offset }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { + offset, + disambiguation: "compatible" +}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { + offset, + disambiguation: "earlier" +}) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]"); +assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { + offset, + disambiguation: "later" +}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]"); +assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, { + offset, + disambiguation: "reject" +})); + +// throw when bad disambiguation +[ + "", + "EARLIER", + "balance" +].forEach(disambiguation => { + assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-11-01T04:00[America/Los_Angeles]", { disambiguation })); +}); diff --git a/test/staging/Temporal/ZonedDateTime/old/subtract.js b/test/staging/Temporal/ZonedDateTime/old/subtract.js new file mode 100644 index 0000000000..0737765ecb --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/subtract.js @@ -0,0 +1,29 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.subtract() +features: [Temporal] +---*/ + +var zdt = Temporal.ZonedDateTime.from("1969-12-25T12:23:45.678901234+00:00[UTC]"); + +// inst.subtract(durationObj) +var earlier = zdt.subtract(Temporal.Duration.from("PT240H0.000000800S")); +assert.sameValue(`${ earlier }`, "1969-12-15T12:23:45.678900434+00:00[UTC]"); + +// casts argument +assert.sameValue(`${ zdt.subtract("PT240H0.000000800S") }`, "1969-12-15T12:23:45.678900434+00:00[UTC]"); +var mar31 = Temporal.ZonedDateTime.from("2020-03-31T15:00-07:00[America/Vancouver]"); + +// constrain when ambiguous result +assert.sameValue(`${ mar31.subtract({ months: 1 }) }`, "2020-02-29T15:00:00-08:00[America/Vancouver]"); +assert.sameValue(`${ mar31.subtract({ months: 1 }, { overflow: "constrain" }) }`, "2020-02-29T15:00:00-08:00[America/Vancouver]"); + +// symmetrical with regard to negative durations in the time part +assert.sameValue(`${ mar31.subtract({ minutes: -30 }) }`, "2020-03-31T15:30:00-07:00[America/Vancouver]"); +assert.sameValue(`${ mar31.subtract({ seconds: -30 }) }`, "2020-03-31T15:00:30-07:00[America/Vancouver]"); + +// throw when ambiguous result with reject +assert.throws(RangeError, () => mar31.subtract({ months: 1 }, { overflow: "reject" })); diff --git a/test/staging/Temporal/ZonedDateTime/old/toInstant.js b/test/staging/Temporal/ZonedDateTime/old/toInstant.js new file mode 100644 index 0000000000..c97b4ef1f3 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/toInstant.js @@ -0,0 +1,33 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.toInstant() +features: [Temporal] +---*/ + + +// recent date +var zdt = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102+01:00[Europe/Amsterdam]"); +assert.sameValue(`${ zdt.toInstant() }`, "2019-10-29T09:46:38.271986102Z"); + +// year ≤ 99 +var zdt = Temporal.ZonedDateTime.from("0098-10-29T10:46:38.271986102+00:00[UTC]"); +assert.sameValue(`${ zdt.toInstant() }`, "0098-10-29T10:46:38.271986102Z"); +zdt = Temporal.ZonedDateTime.from("+000098-10-29T10:46:38.271986102+00:00[UTC]"); +assert.sameValue(`${ zdt.toInstant() }`, "0098-10-29T10:46:38.271986102Z"); + +// year < 1 +var zdt = Temporal.ZonedDateTime.from("0000-10-29T10:46:38.271986102+00:00[UTC]"); +assert.sameValue(`${ zdt.toInstant() }`, "0000-10-29T10:46:38.271986102Z"); +zdt = Temporal.ZonedDateTime.from("+000000-10-29T10:46:38.271986102+00:00[UTC]"); +assert.sameValue(`${ zdt.toInstant() }`, "0000-10-29T10:46:38.271986102Z"); +zdt = Temporal.ZonedDateTime.from("-001000-10-29T10:46:38.271986102+00:00[UTC]"); +assert.sameValue(`${ zdt.toInstant() }`, "-001000-10-29T10:46:38.271986102Z"); + +// year 0 leap day +var zdt = Temporal.ZonedDateTime.from("0000-02-29T00:00-00:01:15[Europe/London]"); +assert.sameValue(`${ zdt.toInstant() }`, "0000-02-29T00:01:15Z"); +zdt = Temporal.ZonedDateTime.from("+000000-02-29T00:00-00:01:15[Europe/London]"); +assert.sameValue(`${ zdt.toInstant() }`, "0000-02-29T00:01:15Z"); diff --git a/test/staging/Temporal/ZonedDateTime/old/toPlainDate.js b/test/staging/Temporal/ZonedDateTime/old/toPlainDate.js new file mode 100644 index 0000000000..4e966057fb --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/toPlainDate.js @@ -0,0 +1,21 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.toPlainDate() +features: [Temporal] +---*/ + +var tz = new Temporal.TimeZone("America/Los_Angeles"); + +// works +var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz); +assert.sameValue(`${ zdt.toPlainDate() }`, "2019-10-29"); + +// preserves the calendar +var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTime({ + timeZone: tz, + calendar: "gregory" +}); +assert.sameValue(zdt.toPlainDate().calendar.id, "gregory"); diff --git a/test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js b/test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js new file mode 100644 index 0000000000..3869d2c4cb --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js @@ -0,0 +1,21 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.toPlainMonthDay() +features: [Temporal] +---*/ + +var tz = new Temporal.TimeZone("America/Los_Angeles"); + +// works +var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz); +assert.sameValue(`${ zdt.toPlainMonthDay() }`, "10-29"); + +// preserves the calendar +var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTime({ + timeZone: tz, + calendar: "gregory" +}); +assert.sameValue(zdt.toPlainMonthDay().calendar.id, "gregory"); diff --git a/test/staging/Temporal/ZonedDateTime/old/toPlainTime.js b/test/staging/Temporal/ZonedDateTime/old/toPlainTime.js new file mode 100644 index 0000000000..b899be5d9f --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/toPlainTime.js @@ -0,0 +1,14 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.toPlainTime() +features: [Temporal] +---*/ + +var tz = new Temporal.TimeZone("America/Los_Angeles"); + +// works +var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz); +assert.sameValue(`${ zdt.toPlainTime() }`, "02:46:38.271986102"); diff --git a/test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js b/test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js new file mode 100644 index 0000000000..c54ed6e8cd --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js @@ -0,0 +1,21 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.toPlainYearMonth() +features: [Temporal] +---*/ + +var tz = new Temporal.TimeZone("America/Los_Angeles"); + +// works +var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz); +assert.sameValue(`${ zdt.toPlainYearMonth() }`, "2019-10"); + +// preserves the calendar +var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTime({ + timeZone: tz, + calendar: "gregory" +}); +assert.sameValue(zdt.toPlainYearMonth().calendar.id, "gregory"); diff --git a/test/staging/Temporal/ZonedDateTime/old/toString.js b/test/staging/Temporal/ZonedDateTime/old/toString.js new file mode 100644 index 0000000000..69ef400751 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/toString.js @@ -0,0 +1,71 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.toString() +features: [Temporal] +---*/ + +var zdt1 = Temporal.ZonedDateTime.from("1976-11-18T15:23+01:00[Europe/Vienna]"); + +// shows only non-ISO calendar if calendarName = auto +assert.sameValue(zdt1.toString({ calendarName: "auto" }), "1976-11-18T15:23:00+01:00[Europe/Vienna]"); +assert.sameValue(zdt1.withCalendar("gregory").toString({ calendarName: "auto" }), "1976-11-18T15:23:00+01:00[Europe/Vienna][u-ca=gregory]"); + +// shows ISO calendar if calendarName = always +assert.sameValue(zdt1.toString({ calendarName: "always" }), "1976-11-18T15:23:00+01:00[Europe/Vienna][u-ca=iso8601]"); + +// omits non-ISO calendar if calendarName = never +assert.sameValue(zdt1.withCalendar("gregory").toString({ calendarName: "never" }), "1976-11-18T15:23:00+01:00[Europe/Vienna]"); + +// throws on invalid calendar +[ + "ALWAYS", + "sometimes", + false, +].forEach(calendarName => { + assert.throws(RangeError, () => zdt1.toString({ calendarName })); +}); + +// shows time zone if timeZoneName = auto +assert.sameValue(zdt1.toString({ timeZoneName: "auto" }), "1976-11-18T15:23:00+01:00[Europe/Vienna]"); + +// omits time zone if timeZoneName = never +assert.sameValue(zdt1.toString({ timeZoneName: "never" }), "1976-11-18T15:23:00+01:00"); + +// shows offset if offset = auto +assert.sameValue(zdt1.toString({ offset: "auto" }), "1976-11-18T15:23:00+01:00[Europe/Vienna]"); + +// omits offset if offset = never +assert.sameValue(zdt1.toString({ offset: "never" }), "1976-11-18T15:23:00[Europe/Vienna]"); + +// combinations of calendar, time zone, and offset +var zdt = zdt1.withCalendar("gregory"); +assert.sameValue(zdt.toString({ + timeZoneName: "never", + calendarName: "never" +}), "1976-11-18T15:23:00+01:00"); +assert.sameValue(zdt.toString({ + offset: "never", + calendarName: "never" +}), "1976-11-18T15:23:00[Europe/Vienna]"); +assert.sameValue(zdt.toString({ + offset: "never", + timeZoneName: "never" +}), "1976-11-18T15:23:00[u-ca=gregory]"); +assert.sameValue(zdt.toString({ + offset: "never", + timeZoneName: "never", + calendarName: "never" +}), "1976-11-18T15:23:00"); + +// rounding up to a nonexistent wall-clock time +var zdt5 = Temporal.ZonedDateTime.from("2018-11-03T23:59:59.999999999-03:00[America/Sao_Paulo]"); +var roundedString = zdt5.toString({ + fractionalSecondDigits: 8, + roundingMode: "halfExpand" +}); +assert.sameValue(roundedString, "2018-11-04T01:00:00.00000000-02:00[America/Sao_Paulo]"); +var zdt6 = Temporal.ZonedDateTime.from(roundedString); +assert.sameValue(zdt6.epochNanoseconds - zdt5.epochNanoseconds, 1n); diff --git a/test/staging/Temporal/ZonedDateTime/old/until.js b/test/staging/Temporal/ZonedDateTime/old/until.js new file mode 100644 index 0000000000..43ab4c2294 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/until.js @@ -0,0 +1,520 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.until() +features: [Temporal] +---*/ + +var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]"); + +// zdt.until(later) === later.since(zdt) with default options +var later = Temporal.ZonedDateTime.from({ + year: 2016, + month: 3, + day: 3, + hour: 18, + timeZone: "Europe/Vienna" +}); +assert.sameValue(`${ zdt.until(later) }`, `${ later.since(zdt) }`); + +// casts argument +assert.sameValue(`${ zdt.until({ + year: 2019, + month: 10, + day: 29, + hour: 10, + timeZone: "Europe/Vienna" +}) }`, "PT376434H36M29.876543211S"); +assert.sameValue(`${ zdt.until("2019-10-29T10:46:38.271986102+01:00[Europe/Vienna]") }`, "PT376435H23M8.148529313S"); +var feb20 = Temporal.ZonedDateTime.from("2020-02-01T00:00+01:00[Europe/Vienna]"); +var feb21 = Temporal.ZonedDateTime.from("2021-02-01T00:00+01:00[Europe/Vienna]"); + +// defaults to returning hours +assert.sameValue(`${ feb20.until(feb21) }`, "PT8784H"); +assert.sameValue(`${ feb20.until(feb21, { largestUnit: "auto" }) }`, "PT8784H"); +assert.sameValue(`${ feb20.until(feb21, { largestUnit: "hours" }) }`, "PT8784H"); +assert.sameValue(`${ feb20.until(Temporal.ZonedDateTime.from("2021-02-01T00:00:00.000000001+01:00[Europe/Vienna]")) }`, "PT8784H0.000000001S"); +assert.sameValue(`${ Temporal.ZonedDateTime.from("2020-02-01T00:00:00.000000001+01:00[Europe/Vienna]").until(feb21) }`, "PT8783H59M59.999999999S"); + +// can return lower or higher units +assert.sameValue(`${ feb20.until(feb21, { largestUnit: "years" }) }`, "P1Y"); +assert.sameValue(`${ feb20.until(feb21, { largestUnit: "months" }) }`, "P12M"); +assert.sameValue(`${ feb20.until(feb21, { largestUnit: "weeks" }) }`, "P52W2D"); +assert.sameValue(`${ feb20.until(feb21, { largestUnit: "days" }) }`, "P366D"); +assert.sameValue(`${ feb20.until(feb21, { largestUnit: "minutes" }) }`, "PT527040M"); +assert.sameValue(`${ feb20.until(feb21, { largestUnit: "seconds" }) }`, "PT31622400S"); + +// can return subseconds +var later = feb20.add({ + days: 1, + milliseconds: 250, + microseconds: 250, + nanoseconds: 250 +}); +var msDiff = feb20.until(later, { largestUnit: "milliseconds" }); +assert.sameValue(msDiff.seconds, 0); +assert.sameValue(msDiff.milliseconds, 86400250); +assert.sameValue(msDiff.microseconds, 250); +assert.sameValue(msDiff.nanoseconds, 250); +var µsDiff = feb20.until(later, { largestUnit: "microseconds" }); +assert.sameValue(µsDiff.milliseconds, 0); +assert.sameValue(µsDiff.microseconds, 86400250250); +assert.sameValue(µsDiff.nanoseconds, 250); +var nsDiff = feb20.until(later, { largestUnit: "nanoseconds" }); +assert.sameValue(nsDiff.microseconds, 0); +assert.sameValue(nsDiff.nanoseconds, 86400250250250); + +// does not include higher units than necessary +var lastFeb20 = Temporal.ZonedDateTime.from("2020-02-29T00:00+01:00[Europe/Vienna]"); +var lastJan21 = Temporal.ZonedDateTime.from("2021-01-31T00:00+01:00[Europe/Vienna]"); +assert.sameValue(`${ lastFeb20.until(lastJan21) }`, "PT8088H"); +assert.sameValue(`${ lastFeb20.until(lastJan21, { largestUnit: "months" }) }`, "P11M2D"); +assert.sameValue(`${ lastFeb20.until(lastJan21, { largestUnit: "years" }) }`, "P11M2D"); + +// weeks and months are mutually exclusive +var laterDateTime = zdt.add({ + days: 42, + hours: 3 +}); +var weeksDifference = zdt.until(laterDateTime, { largestUnit: "weeks" }); +assert.notSameValue(weeksDifference.weeks, 0); +assert.sameValue(weeksDifference.months, 0); +var monthsDifference = zdt.until(laterDateTime, { largestUnit: "months" }); +assert.sameValue(monthsDifference.weeks, 0); +assert.notSameValue(monthsDifference.months, 0); + +// no two different calendars +var zdt1 = new Temporal.ZonedDateTime(0n, "UTC"); +var zdt2 = new Temporal.ZonedDateTime(0n, "UTC", Temporal.Calendar.from("japanese")); +assert.throws(RangeError, () => zdt1.until(zdt2)); + +var earlier = Temporal.ZonedDateTime.from('2019-01-08T09:22:36.123456789+01:00[Europe/Vienna]'); +var later = Temporal.ZonedDateTime.from('2021-09-07T14:39:40.987654321+02:00[Europe/Vienna]'); +// assumes a different default for largestUnit if smallestUnit is larger than hours +assert.sameValue(`${ earlier.until(later, { + smallestUnit: "years", + roundingMode: "halfExpand" +}) }`, "P3Y"); +assert.sameValue(`${ earlier.until(later, { + smallestUnit: "months", + roundingMode: "halfExpand" +}) }`, "P32M"); +assert.sameValue(`${ earlier.until(later, { + smallestUnit: "weeks", + roundingMode: "halfExpand" +}) }`, "P139W"); +assert.sameValue(`${ earlier.until(later, { + smallestUnit: "days", + roundingMode: "halfExpand" +}) }`, "P973D"); +var incrementOneNearest = [ + [ + "years", + "P3Y" + ], + [ + "months", + "P32M" + ], + [ + "weeks", + "P139W" + ], + [ + "days", + "P973D" + ], + [ + "hours", + "PT23356H" + ], + [ + "minutes", + "PT23356H17M" + ], + [ + "seconds", + "PT23356H17M5S" + ], + [ + "milliseconds", + "PT23356H17M4.864S" + ], + [ + "microseconds", + "PT23356H17M4.864198S" + ], + [ + "nanoseconds", + "PT23356H17M4.864197532S" + ] +]; +incrementOneNearest.forEach(([smallestUnit, expected]) => { + var roundingMode = "halfExpand"; + assert.sameValue(`${ earlier.until(later, { + smallestUnit, + roundingMode + }) }`, expected); + assert.sameValue(`${ later.until(earlier, { + smallestUnit, + roundingMode + }) }`, `-${ expected }`); +}); +var incrementOneCeil = [ + [ + "years", + "P3Y", + "-P2Y" + ], + [ + "months", + "P32M", + "-P31M" + ], + [ + "weeks", + "P140W", + "-P139W" + ], + [ + "days", + "P974D", + "-P973D" + ], + [ + "hours", + "PT23357H", + "-PT23356H" + ], + [ + "minutes", + "PT23356H18M", + "-PT23356H17M" + ], + [ + "seconds", + "PT23356H17M5S", + "-PT23356H17M4S" + ], + [ + "milliseconds", + "PT23356H17M4.865S", + "-PT23356H17M4.864S" + ], + [ + "microseconds", + "PT23356H17M4.864198S", + "-PT23356H17M4.864197S" + ], + [ + "nanoseconds", + "PT23356H17M4.864197532S", + "-PT23356H17M4.864197532S" + ] +]; +incrementOneCeil.forEach(([smallestUnit, expectedPositive, expectedNegative]) => { + var roundingMode = "ceil"; + assert.sameValue(`${ earlier.until(later, { + smallestUnit, + roundingMode + }) }`, expectedPositive); + assert.sameValue(`${ later.until(earlier, { + smallestUnit, + roundingMode + }) }`, expectedNegative); +}); +var incrementOneFloor = [ + [ + "years", + "P2Y", + "-P3Y" + ], + [ + "months", + "P31M", + "-P32M" + ], + [ + "weeks", + "P139W", + "-P140W" + ], + [ + "days", + "P973D", + "-P974D" + ], + [ + "hours", + "PT23356H", + "-PT23357H" + ], + [ + "minutes", + "PT23356H17M", + "-PT23356H18M" + ], + [ + "seconds", + "PT23356H17M4S", + "-PT23356H17M5S" + ], + [ + "milliseconds", + "PT23356H17M4.864S", + "-PT23356H17M4.865S" + ], + [ + "microseconds", + "PT23356H17M4.864197S", + "-PT23356H17M4.864198S" + ], + [ + "nanoseconds", + "PT23356H17M4.864197532S", + "-PT23356H17M4.864197532S" + ] +]; +incrementOneFloor.forEach(([smallestUnit, expectedPositive, expectedNegative]) => { + var roundingMode = "floor"; + assert.sameValue(`${ earlier.until(later, { + smallestUnit, + roundingMode + }) }`, expectedPositive); + assert.sameValue(`${ later.until(earlier, { + smallestUnit, + roundingMode + }) }`, expectedNegative); +}); +var incrementOneTrunc = [ + [ + "years", + "P2Y" + ], + [ + "months", + "P31M" + ], + [ + "weeks", + "P139W" + ], + [ + "days", + "P973D" + ], + [ + "hours", + "PT23356H" + ], + [ + "minutes", + "PT23356H17M" + ], + [ + "seconds", + "PT23356H17M4S" + ], + [ + "milliseconds", + "PT23356H17M4.864S" + ], + [ + "microseconds", + "PT23356H17M4.864197S" + ], + [ + "nanoseconds", + "PT23356H17M4.864197532S" + ] +]; +incrementOneTrunc.forEach(([smallestUnit, expected]) => { + var roundingMode = "trunc"; + assert.sameValue(`${ earlier.until(later, { + smallestUnit, + roundingMode + }) }`, expected); + assert.sameValue(`${ later.until(earlier, { + smallestUnit, + roundingMode + }) }`, `-${ expected }`); +}); + +// rounds to an increment of hours +assert.sameValue(`${ earlier.until(later, { + smallestUnit: "hours", + roundingIncrement: 3, + roundingMode: "halfExpand" +}) }`, "PT23355H"); + +// rounds to an increment of minutes +assert.sameValue(`${ earlier.until(later, { + smallestUnit: "minutes", + roundingIncrement: 30, + roundingMode: "halfExpand" +}) }`, "PT23356H30M"); + +// rounds to an increment of seconds +assert.sameValue(`${ earlier.until(later, { + smallestUnit: "seconds", + roundingIncrement: 15, + roundingMode: "halfExpand" +}) }`, "PT23356H17M"); + +// rounds to an increment of milliseconds +assert.sameValue(`${ earlier.until(later, { + smallestUnit: "milliseconds", + roundingIncrement: 10, + roundingMode: "halfExpand" +}) }`, "PT23356H17M4.86S"); + +// rounds to an increment of microseconds +assert.sameValue(`${ earlier.until(later, { + smallestUnit: "microseconds", + roundingIncrement: 10, + roundingMode: "halfExpand" +}) }`, "PT23356H17M4.8642S"); + +// rounds to an increment of nanoseconds +assert.sameValue(`${ earlier.until(later, { + smallestUnit: "nanoseconds", + roundingIncrement: 10, + roundingMode: "halfExpand" +}) }`, "PT23356H17M4.86419753S"); + +// valid hour increments divide into 24 +[ + 1, + 2, + 3, + 4, + 6, + 8, + 12 +].forEach(roundingIncrement => { + var options = { + smallestUnit: "hours", + roundingIncrement + }; + assert(earlier.until(later, options) instanceof Temporal.Duration); +}); +[ + "minutes", + "seconds" +].forEach(smallestUnit => { + [ + 1, + 2, + 3, + 4, + 5, + 6, + 10, + 12, + 15, + 20, + 30 + ].forEach(roundingIncrement => { + var options = { + smallestUnit, + roundingIncrement + }; + assert(earlier.until(later, options) instanceof Temporal.Duration); + }); +}); +[ + "milliseconds", + "microseconds", + "nanoseconds" +].forEach(smallestUnit => { + [ + 1, + 2, + 4, + 5, + 8, + 10, + 20, + 25, + 40, + 50, + 100, + 125, + 200, + 250, + 500 + ].forEach(roundingIncrement => { + var options = { + smallestUnit, + roundingIncrement + }; + assert(earlier.until(later, options) instanceof Temporal.Duration); + }); +}); + +// throws on increments that do not divide evenly into the next highest +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "hours", + roundingIncrement: 11 +})); +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "minutes", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "seconds", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "milliseconds", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "microseconds", + roundingIncrement: 29 +})); +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "nanoseconds", + roundingIncrement: 29 +})); + +// throws on increments that are equal to the next highest +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "hours", + roundingIncrement: 24 +})); +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "minutes", + roundingIncrement: 60 +})); +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "seconds", + roundingIncrement: 60 +})); +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "milliseconds", + roundingIncrement: 1000 +})); +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "microseconds", + roundingIncrement: 1000 +})); +assert.throws(RangeError, () => earlier.until(later, { + smallestUnit: "nanoseconds", + roundingIncrement: 1000 +})); + +// rounds relative to the receiver +var dt1 = Temporal.ZonedDateTime.from("2019-01-01T00:00+00:00[UTC]"); +var dt2 = Temporal.ZonedDateTime.from("2020-07-02T00:00+00:00[UTC]"); +assert.sameValue(`${ dt1.until(dt2, { + smallestUnit: "years", + roundingMode: "halfExpand" +}) }`, "P2Y"); +assert.sameValue(`${ dt2.until(dt1, { + smallestUnit: "years", + roundingMode: "halfExpand" +}) }`, "-P1Y"); + diff --git a/test/staging/Temporal/ZonedDateTime/old/with.js b/test/staging/Temporal/ZonedDateTime/old/with.js new file mode 100644 index 0000000000..9273b51b10 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/with.js @@ -0,0 +1,267 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.with() +features: [Temporal] +---*/ + +var zdt = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789).toZonedDateTime("UTC"); + +// zdt.with({ year: 2019 } works +assert.sameValue(`${ zdt.with({ year: 2019 }) }`, "2019-11-18T15:23:30.123456789+00:00[UTC]"); + +// zdt.with({ month: 5 } works +assert.sameValue(`${ zdt.with({ month: 5 }) }`, "1976-05-18T15:23:30.123456789+00:00[UTC]"); + +// zdt.with({ monthCode: "M05" }) works +assert.sameValue(`${ zdt.with({ monthCode: "M05" }) }`, "1976-05-18T15:23:30.123456789+00:00[UTC]"); + +// month and monthCode must agree +assert.throws(RangeError, () => zdt.with({ + month: 5, + monthCode: "M06" +})); + +// zdt.with({ day: 5 } works +assert.sameValue(`${ zdt.with({ day: 5 }) }`, "1976-11-05T15:23:30.123456789+00:00[UTC]"); + +// zdt.with({ hour: 5 } works +assert.sameValue(`${ zdt.with({ hour: 5 }) }`, "1976-11-18T05:23:30.123456789+00:00[UTC]"); + +// zdt.with({ minute: 5 } works +assert.sameValue(`${ zdt.with({ minute: 5 }) }`, "1976-11-18T15:05:30.123456789+00:00[UTC]"); + +// zdt.with({ second: 5 } works +assert.sameValue(`${ zdt.with({ second: 5 }) }`, "1976-11-18T15:23:05.123456789+00:00[UTC]"); + +// zdt.with({ millisecond: 5 } works +assert.sameValue(`${ zdt.with({ millisecond: 5 }) }`, "1976-11-18T15:23:30.005456789+00:00[UTC]"); + +// zdt.with({ microsecond: 5 } works +assert.sameValue(`${ zdt.with({ microsecond: 5 }) }`, "1976-11-18T15:23:30.123005789+00:00[UTC]"); + +// zdt.with({ nanosecond: 5 } works +assert.sameValue(`${ zdt.with({ nanosecond: 5 }) }`, "1976-11-18T15:23:30.123456005+00:00[UTC]"); + +// zdt.with({ month: 5, second: 15 } works +assert.sameValue(`${ zdt.with({ + month: 5, + second: 15 +}) }`, "1976-05-18T15:23:15.123456789+00:00[UTC]"); + +// Overflow options +// constrain +var overflow = "constrain"; +assert.sameValue(`${ zdt.with({ month: 29 }, { overflow }) }`, "1976-12-18T15:23:30.123456789+00:00[UTC]"); +assert.sameValue(`${ zdt.with({ day: 31 }, { overflow }) }`, "1976-11-30T15:23:30.123456789+00:00[UTC]"); +assert.sameValue(`${ zdt.with({ hour: 29 }, { overflow }) }`, "1976-11-18T23:23:30.123456789+00:00[UTC]"); +assert.sameValue(`${ zdt.with({ nanosecond: 9000 }, { overflow }) }`, "1976-11-18T15:23:30.123456999+00:00[UTC]"); + +// reject +var overflow = "reject"; +assert.throws(RangeError, () => zdt.with({ month: 29 }, { overflow })); +assert.throws(RangeError, () => zdt.with({ day: 31 }, { overflow })); +assert.throws(RangeError, () => zdt.with({ hour: 29 }, { overflow })); +assert.throws(RangeError, () => zdt.with({ nanosecond: 9000 }, { overflow })); + +var dstStartDay = Temporal.ZonedDateTime.from("2019-03-10T12:00:01-02:30[America/St_Johns]"); +var dstEndDay = Temporal.ZonedDateTime.from("2019-11-03T12:00:01-03:30[America/St_Johns]"); +var oneThirty = { +hour: 1, +minute: 30 +}; +var twoThirty = { +hour: 2, +minute: 30 +}; + +// Disambiguation options +var offset = "ignore"; +// compatible, skipped wall time +assert.sameValue(`${ dstStartDay.with(twoThirty, { + offset, + disambiguation: "compatible" +}) }`, "2019-03-10T03:30:01-02:30[America/St_Johns]"); + +// earlier, skipped wall time +assert.sameValue(`${ dstStartDay.with(twoThirty, { + offset, + disambiguation: "earlier" +}) }`, "2019-03-10T01:30:01-03:30[America/St_Johns]"); + +// later, skipped wall time +assert.sameValue(`${ dstStartDay.with(twoThirty, { + offset, + disambiguation: "later" +}) }`, "2019-03-10T03:30:01-02:30[America/St_Johns]"); + +// compatible, repeated wall time +assert.sameValue(`${ dstEndDay.with(oneThirty, { + offset, + disambiguation: "compatible" +}) }`, "2019-11-03T01:30:01-02:30[America/St_Johns]"); + +// earlier, repeated wall time +assert.sameValue(`${ dstEndDay.with(oneThirty, { + offset, + disambiguation: "earlier" +}) }`, "2019-11-03T01:30:01-02:30[America/St_Johns]"); + +// later, repeated wall time +assert.sameValue(`${ dstEndDay.with(oneThirty, { + offset, + disambiguation: "later" +}) }`, "2019-11-03T01:30:01-03:30[America/St_Johns]"); + +// reject +assert.throws(RangeError, () => dstStartDay.with(twoThirty, { + offset, + disambiguation: "reject" +})); +assert.throws(RangeError, () => dstEndDay.with(oneThirty, { + offset, + disambiguation: "reject" +})); + +// compatible is the default +assert.sameValue(`${ dstStartDay.with(twoThirty, { offset }) }`, `${ dstStartDay.with(twoThirty, { + offset, + disambiguation: "compatible" +}) }`); +assert.sameValue(`${ dstEndDay.with(twoThirty, { offset }) }`, `${ dstEndDay.with(twoThirty, { + offset, + disambiguation: "compatible" +}) }`); + +// invalid disambiguation +[ + "", + "EARLIER", + "balance" +].forEach(disambiguation => assert.throws(RangeError, () => zdt.with({ day: 5 }, { disambiguation }))); + +// Offset options +var bogus = { + ...twoThirty, + offset: "+23:59" +}; +// use, with bogus offset, changes to the exact time with the offset +var preserveExact = dstStartDay.with(bogus, { offset: "use" }); +assert.sameValue(`${ preserveExact }`, "2019-03-08T23:01:01-03:30[America/St_Johns]"); +assert.sameValue(preserveExact.epochNanoseconds, Temporal.Instant.from("2019-03-10T02:30:01+23:59").epochNanoseconds); + +// ignore, with bogus offset, defers to disambiguation option +var offset = "ignore"; +assert.sameValue(`${ dstStartDay.with(bogus, { + offset, + disambiguation: "earlier" +}) }`, "2019-03-10T01:30:01-03:30[America/St_Johns]"); +assert.sameValue(`${ dstStartDay.with(bogus, { + offset, + disambiguation: "later" +}) }`, "2019-03-10T03:30:01-02:30[America/St_Johns]"); + +// prefer, with bogus offset, defers to disambiguation option +var offset = "prefer"; +assert.sameValue(`${ dstStartDay.with(bogus, { + offset, + disambiguation: "earlier" +}) }`, "2019-03-10T01:30:01-03:30[America/St_Johns]"); +assert.sameValue(`${ dstStartDay.with(bogus, { + offset, + disambiguation: "later" +}) }`, "2019-03-10T03:30:01-02:30[America/St_Johns]"); + +// reject, with bogus offset, throws +assert.throws(RangeError, () => dstStartDay.with({ + ...twoThirty, + offset: "+23:59" +}, { offset: "reject" })); + +var doubleTime = Temporal.ZonedDateTime.from("2019-11-03T01:30:01-03:30[America/St_Johns]"); +// use changes to the exact time with the offset +var preserveExact = doubleTime.with({ offset: "-02:30" }, { offset: "use" }); +assert.sameValue(preserveExact.offset, "-02:30"); +assert.sameValue(preserveExact.epochNanoseconds, Temporal.Instant.from("2019-11-03T01:30:01-02:30").epochNanoseconds); + +// ignore defers to disambiguation option +var offset = "ignore"; +assert.sameValue(doubleTime.with({ offset: "-02:30" }, { + offset, + disambiguation: "earlier" +}).offset, "-02:30"); +assert.sameValue(doubleTime.with({ offset: "-02:30" }, { + offset, + disambiguation: "later" +}).offset, "-03:30"); + +// prefer adjusts offset of repeated clock time +assert.sameValue(doubleTime.with({ offset: "-02:30" }, { offset: "prefer" }).offset, "-02:30"); + +// reject adjusts offset of repeated clock time +assert.sameValue(doubleTime.with({ offset: "-02:30" }, { offset: "reject" }).offset, "-02:30"); + +// use does not cause the offset to change when adjusting repeated clock time +assert.sameValue(doubleTime.with({ minute: 31 }, { offset: "use" }).offset, "-03:30"); + +// ignore may cause the offset to change when adjusting repeated clock time +assert.sameValue(doubleTime.with({ minute: 31 }, { offset: "ignore" }).offset, "-02:30"); + +// prefer does not cause the offset to change when adjusting repeated clock time +assert.sameValue(doubleTime.with({ minute: 31 }, { offset: "prefer" }).offset, "-03:30"); + +// reject does not cause the offset to change when adjusting repeated clock time +assert.sameValue(doubleTime.with({ minute: 31 }, { offset: "reject" }).offset, "-03:30"); + +// prefer is the default +assert.sameValue(`${ dstStartDay.with(twoThirty) }`, `${ dstStartDay.with(twoThirty, { offset: "prefer" }) }`); +assert.sameValue(`${ dstEndDay.with(twoThirty) }`, `${ dstEndDay.with(twoThirty, { offset: "prefer" }) }`); +assert.sameValue(`${ doubleTime.with({ minute: 31 }) }`, `${ doubleTime.with({ minute: 31 }, { offset: "prefer" }) }`); + +// invalid offset +[ + "", + "PREFER", + "balance" +].forEach(offset => assert.throws(RangeError, () => zdt.with({ day: 5 }, { offset }))); + +// object must contain at least one correctly-spelled property +assert.throws(TypeError, () => zdt.with({})); +assert.throws(TypeError, () => zdt.with({ months: 12 })); + +// incorrectly-spelled properties are ignored +assert.sameValue(`${ zdt.with({ + month: 12, + days: 15 +}) }`, "1976-12-18T15:23:30.123456789+00:00[UTC]"); + +// throws if timeZone is included +assert.throws(TypeError, () => zdt.with({ + month: 2, + timeZone: "Asia/Ulaanbaatar" +})); + +// throws if given a Temporal object with a time zone +assert.throws(TypeError, () => zdt.with(dstStartDay)); + +// throws if calendarName is included +assert.throws(TypeError, () => zdt.with({ + month: 2, + calendar: "japanese" +})); + +// throws if given a Temporal object with a calendar +assert.throws(TypeError, () => zdt.with(Temporal.PlainDateTime.from("1976-11-18T12:00"))); +assert.throws(TypeError, () => zdt.with(Temporal.PlainDate.from("1976-11-18"))); +assert.throws(TypeError, () => zdt.with(Temporal.PlainTime.from("12:00"))); +assert.throws(TypeError, () => zdt.with(Temporal.PlainYearMonth.from("1976-11"))); +assert.throws(TypeError, () => zdt.with(Temporal.PlainMonthDay.from("11-18"))); + +// throws if given a string +assert.throws(TypeError, () => zdt.with("1976-11-18T12:00+00:00[UTC]")); +assert.throws(TypeError, () => zdt.with("1976-11-18")); +assert.throws(TypeError, () => zdt.with("12:00")); +assert.throws(TypeError, () => zdt.with("invalid")); + diff --git a/test/staging/Temporal/ZonedDateTime/old/withCalendar.js b/test/staging/Temporal/ZonedDateTime/old/withCalendar.js new file mode 100644 index 0000000000..e1e5266413 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/withCalendar.js @@ -0,0 +1,21 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.withCalendar() +features: [Temporal] +---*/ + +var zdt = Temporal.ZonedDateTime.from("2019-11-18T15:23:30.123456789-08:00[America/Los_Angeles]"); + +// zonedDateTime.withCalendar(japanese) works +var cal = Temporal.Calendar.from("japanese"); +assert.sameValue(`${ zdt.withCalendar(cal) }`, "2019-11-18T15:23:30.123456789-08:00[America/Los_Angeles][u-ca=japanese]"); + +// keeps instant and time zone the same +var zdt = Temporal.ZonedDateTime.from("2019-11-18T15:23:30.123456789+01:00[Europe/Madrid][u-ca=gregory]"); +var zdt2 = zdt.withCalendar("japanese"); +assert.sameValue(zdt.epochNanoseconds, zdt2.epochNanoseconds); +assert.sameValue(zdt2.calendar.id, "japanese"); +assert.sameValue(zdt2.timeZone.id, "Europe/Madrid"); diff --git a/test/staging/Temporal/ZonedDateTime/old/withPlainDate.js b/test/staging/Temporal/ZonedDateTime/old/withPlainDate.js new file mode 100644 index 0000000000..a728c1f9d9 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/withPlainDate.js @@ -0,0 +1,45 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: .withPlainDate manipulation +features: [Temporal] +---*/ + +var zdt = Temporal.ZonedDateTime.from("1995-12-07T03:24:30[America/Los_Angeles]"); + +// withPlainDate({ year: 2000, month: 6, day: 1 }) works +assert.sameValue(`${ zdt.withPlainDate({ + year: 2000, + month: 6, + day: 1 +}) }`, "2000-06-01T03:24:30-07:00[America/Los_Angeles]"); + +// withPlainDate(plainDate) works +var date = Temporal.PlainDate.from("2020-01-23"); +assert.sameValue(`${ zdt.withPlainDate(date) }`, "2020-01-23T03:24:30-08:00[America/Los_Angeles]"); + +// withPlainDate('2018-09-15') works +assert.sameValue(`${ zdt.withPlainDate("2018-09-15") }`, "2018-09-15T03:24:30-07:00[America/Los_Angeles]"); + +// result contains a non-ISO calendar if present in the input +assert.sameValue(`${ zdt.withCalendar("japanese").withPlainDate("2008-09-06") }`, "2008-09-06T03:24:30-07:00[America/Los_Angeles][u-ca=japanese]"); + +// calendar is unchanged if input has ISO calendar +assert.sameValue(`${ zdt.withPlainDate("2008-09-06[u-ca=japanese]") }`, "2008-09-06T03:24:30-07:00[America/Los_Angeles][u-ca=japanese]"); + +// throws if both `this` and `other` have a non-ISO calendar +assert.throws(RangeError, () => zdt.withCalendar("gregory").withPlainDate("2008-09-06-07:00[America/Los_Angeles][u-ca=japanese]")); + +// object must contain at least one correctly-spelled property +assert.throws(TypeError, () => zdt.withPlainDate({})); +assert.throws(TypeError, () => zdt.withPlainDate({ months: 12 })); + +// incorrectly-spelled properties are ignored +assert.sameValue(`${ zdt.withPlainDate({ + year: 2000, + month: 6, + day: 1, + months: 123 +}) }`, "2000-06-01T03:24:30-07:00[America/Los_Angeles]"); diff --git a/test/staging/Temporal/ZonedDateTime/old/withPlainTime.js b/test/staging/Temporal/ZonedDateTime/old/withPlainTime.js new file mode 100644 index 0000000000..8b7accbf89 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/withPlainTime.js @@ -0,0 +1,26 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: .withPlainTime manipulation +features: [Temporal] +---*/ + +var zdt = Temporal.ZonedDateTime.from("2015-12-07T03:24:30.000003500[America/Los_Angeles]"); + +// withPlainTime({ hour: 10 }) works +assert.sameValue(`${ zdt.withPlainTime({ hour: 10 }) }`, "2015-12-07T10:00:00-08:00[America/Los_Angeles]"); + +// withPlainTime(time) works +var time = Temporal.PlainTime.from("11:22"); +assert.sameValue(`${ zdt.withPlainTime(time) }`, "2015-12-07T11:22:00-08:00[America/Los_Angeles]"); + +// withPlainTime('12:34') works +assert.sameValue(`${ zdt.withPlainTime("12:34") }`, "2015-12-07T12:34:00-08:00[America/Los_Angeles]"); + +// incorrectly-spelled properties are ignored +assert.sameValue(`${ zdt.withPlainTime({ + hour: 10, + seconds: 55 +}) }`, "2015-12-07T10:00:00-08:00[America/Los_Angeles]"); diff --git a/test/staging/Temporal/ZonedDateTime/old/withTimezone.js b/test/staging/Temporal/ZonedDateTime/old/withTimezone.js new file mode 100644 index 0000000000..8628aacc28 --- /dev/null +++ b/test/staging/Temporal/ZonedDateTime/old/withTimezone.js @@ -0,0 +1,20 @@ +// Copyright (C) 2018 Bloomberg LP. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-temporal-zoneddatetime-objects +description: Temporal.ZonedDateTime.prototype.withTimeZone() +features: [Temporal] +---*/ + +var tz = new Temporal.TimeZone("America/Los_Angeles"); +var instant = Temporal.Instant.from("2019-11-18T15:23:30.123456789-08:00[America/Los_Angeles]"); +var zdt = instant.toZonedDateTimeISO("UTC"); + +// keeps instant and calendar the same +var zdt = Temporal.ZonedDateTime.from("2019-11-18T15:23:30.123456789+01:00[Europe/Madrid][u-ca=gregory]"); +var zdt2 = zdt.withTimeZone("America/Vancouver"); +assert.sameValue(zdt.epochNanoseconds, zdt2.epochNanoseconds); +assert.sameValue(zdt2.calendar.id, "gregory"); +assert.sameValue(zdt2.timeZone.id, "America/Vancouver"); +assert.notSameValue(`${ zdt.toPlainDateTime() }`, `${ zdt2.toPlainDateTime() }`);