tyler.durden
/
test262
mirror of https://github.com/tc39/test262.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add proposal-temporal's old demitasse tests to staging

This commit is contained in:
Aditi 2022-08-09 16:41:13 +05:30 committed by Philip Chimento
parent 8c64a666e1
commit 6a99a28dd8
58 changed files with 7236 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

149
test/staging/Temporal/Duration/old/add.js Normal file
View File

@ -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
}
}));

13
test/staging/Temporal/Duration/old/compare-no-precision-loss.js Normal file
View File

@ -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);

92
test/staging/Temporal/Duration/old/limits.js Normal file
View File

@ -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", ".");

902
test/staging/Temporal/Duration/old/round.js Normal file
View File

@ -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");

123
test/staging/Temporal/Duration/old/subtract.js Normal file
View File

@ -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
}
}));

32
test/staging/Temporal/Duration/old/toString.js Normal file
View File

@ -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");

475
test/staging/Temporal/Duration/old/total.js Normal file
View File

@ -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);

268
test/staging/Temporal/Regex/old/duration.js Normal file
View File

@ -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
});
}
}

264
test/staging/Temporal/Regex/old/instant.js Normal file
View File

@ -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
]);

81
test/staging/Temporal/Regex/old/plaindate.js Normal file
View File

@ -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
]);

71
test/staging/Temporal/Regex/old/plaindatetime.js Normal file
View File

@ -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
]));

75
test/staging/Temporal/Regex/old/plainmonthday.js Normal file
View File

@ -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
]);

63
test/staging/Temporal/Regex/old/plaintime.js Normal file
View File

@ -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
]));

106
test/staging/Temporal/Regex/old/plainyearmonth.js Normal file
View File

@ -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
]);

101
test/staging/Temporal/Regex/old/timezone.js Normal file
View File

@ -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");

26
test/staging/Temporal/TimeZone/old/dst-change.js Normal file
View File

@ -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" }));

47
test/staging/Temporal/TimeZone/old/getInstantFor-disambiguation.js Normal file
View File

@ -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 })));

58
test/staging/Temporal/TimeZone/old/getInstantFor.js Normal file
View File

@ -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");

30
test/staging/Temporal/TimeZone/old/getNextTransition.js Normal file
View File

@ -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");

44
test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js Normal file
View File

@ -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 }));

24
test/staging/Temporal/TimeZone/old/getPreviousTransition.js Normal file
View File

@ -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");

17
test/staging/Temporal/TimeZone/old/subminute-offset.js Normal file
View File

@ -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)

28
test/staging/Temporal/TimeZone/old/timezone-america-la.js Normal file
View File

@ -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;
}

21
test/staging/Temporal/TimeZone/old/timezone-offset.js Normal file
View File

@ -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")

18
test/staging/Temporal/TimeZone/old/timezone-utc-offset.js Normal file
View File

@ -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)

152
test/staging/Temporal/UserCalendar/old/calendar-extra-fields.js Normal file
View File

@ -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;

146
test/staging/Temporal/UserCalendar/old/calendar-non-trivial-mergefields.js Normal file
View File

@ -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;

191
test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js Normal file
View File

@ -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);

159
test/staging/Temporal/UserCalendar/old/trivial-subclass.js Normal file
View File

@ -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);

77
test/staging/Temporal/UserTimezone/old/subminute-offset.js Normal file
View File

@ -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);

39
test/staging/Temporal/UserTimezone/old/trivial-protocol.js Normal file
View File

@ -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);

115
test/staging/Temporal/UserTimezone/old/trivial-subclass.js Normal file
View File

@ -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);

50
test/staging/Temporal/ZonedDateTime/old/add.js Normal file
View File

@ -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" }));

120
test/staging/Temporal/ZonedDateTime/old/compare.js Normal file
View File

@ -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);

86
test/staging/Temporal/ZonedDateTime/old/construction-and-properties.js Normal file
View File

@ -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]");

23
test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js Normal file
View File

@ -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]");

290
test/staging/Temporal/ZonedDateTime/old/dst-math.js Normal file
View File

@ -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);
}
}
}

57
test/staging/Temporal/ZonedDateTime/old/dst-properties.js Normal file
View File

@ -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);

75
test/staging/Temporal/ZonedDateTime/old/equals.js Normal file
View File

@ -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"
}));

79
test/staging/Temporal/ZonedDateTime/old/order-of-operations.js Normal file
View File

@ -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));

282
test/staging/Temporal/ZonedDateTime/old/property-bags.js Normal file
View File

@ -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");

37
test/staging/Temporal/ZonedDateTime/old/reversibility-of-differences.js Normal file
View File

@ -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));
});

348
test/staging/Temporal/ZonedDateTime/old/round.js Normal file
View File

@ -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);

516
test/staging/Temporal/ZonedDateTime/old/since.js Normal file
View File

@ -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");

157
test/staging/Temporal/ZonedDateTime/old/string-parsing.js Normal file
View File

@ -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 }));
});

29
test/staging/Temporal/ZonedDateTime/old/subtract.js Normal file
View File

@ -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" }));

33
test/staging/Temporal/ZonedDateTime/old/toInstant.js Normal file
View File

@ -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");

21
test/staging/Temporal/ZonedDateTime/old/toPlainDate.js Normal file
View File

@ -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");

21
test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js Normal file
View File

@ -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");

14
test/staging/Temporal/ZonedDateTime/old/toPlainTime.js Normal file
View File

@ -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");

21
test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js Normal file
View File

@ -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");

71
test/staging/Temporal/ZonedDateTime/old/toString.js Normal file
View File

@ -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);

520
test/staging/Temporal/ZonedDateTime/old/until.js Normal file
View File

@ -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");

267
test/staging/Temporal/ZonedDateTime/old/with.js Normal file
View File

@ -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"));

21
test/staging/Temporal/ZonedDateTime/old/withCalendar.js Normal file
View File

@ -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");

45
test/staging/Temporal/ZonedDateTime/old/withPlainDate.js Normal file
View File

@ -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]");

26
test/staging/Temporal/ZonedDateTime/old/withPlainTime.js Normal file
View File

@ -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]");

20
test/staging/Temporal/ZonedDateTime/old/withTimezone.js Normal file
View File

@ -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() }`);