tyler.durden/test262
1
0
Fork 0
mirror of https://github.com/tc39/test262.git synced 2025-09-22 17:48:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Run prettier for easier review of later commits

Browse Source
This commit is contained in:
Justin Grant 2022-12-16 04:54:25 -08:00 committed by Richard Gibson
parent 9821def022
commit f999dea7c0
6 changed files with 319 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

508
test/staging/Intl402/Temporal/old/date-time-format.js
View File

@ -1,4 +1,3 @@
// Copyright (C) 2018 Bloomberg LP. All rights reserved. // Copyright (C) 2018 Bloomberg LP. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file. // This code is governed by the BSD license found in the LICENSE file.
@ -9,15 +8,14 @@ includes: [deepEqual.js]
features: [Temporal] features: [Temporal]
---*/ ---*/
//should return an Array" // should return an Array
assert(Array.isArray(Intl.DateTimeFormat.supportedLocalesOf())); assert(Array.isArray(Intl.DateTimeFormat.supportedLocalesOf()));
var onlyOnce = value => { var onlyOnce = (value) => {
var obj = { var obj = {
calls: 0, calls: 0,
toString() { toString() {
if (++this.calls > 1) if (++this.calls > 1) throw new RangeError("prop read twice");
throw new RangeError("prop read twice");
return value; return value;
} }
}; };
@ -28,8 +26,7 @@ var optionsUS = {
calls: 0, calls: 0,
value: "America/New_York", value: "America/New_York",
get timeZone() { get timeZone() {
if (++this.calls > 1) if (++this.calls > 1) throw new RangeError("prop read twice");
throw new RangeError("prop read twice");
return this.value; return this.value;
}, },
set timeZone(val) { set timeZone(val) {
@ -54,41 +51,41 @@ var t2 = "2020-02-20T15:44:56-05:00[America/New_York]";
var start = new Date("1922-12-30"); var start = new Date("1922-12-30");
var end = new Date("1991-12-26"); var end = new Date("1991-12-26");
//should work for Instant // should work for Instant
assert.sameValue(us.format(Temporal.Instant.from(t1)), "11/18/1976, 9:23:30 AM"); assert.sameValue(us.format(Temporal.Instant.from(t1)), "11/18/1976, 9:23:30 AM");
assert.sameValue(at.format(Temporal.Instant.from(t1)), "18.11.1976, 15:23:30"); assert.sameValue(at.format(Temporal.Instant.from(t1)), "18.11.1976, 15:23:30");
//should work for ZonedDateTime // should work for ZonedDateTime
assert.sameValue(us2.format(Temporal.ZonedDateTime.from(t1)), "11/18/1976, 2:23:30 PM UTC"); assert.sameValue(us2.format(Temporal.ZonedDateTime.from(t1)), "11/18/1976, 2:23:30 PM UTC");
assert.sameValue(at2.format(Temporal.ZonedDateTime.from(t1)), "18.11.1976, 14:23:30 UTC"); assert.sameValue(at2.format(Temporal.ZonedDateTime.from(t1)), "18.11.1976, 14:23:30 UTC");
//should work for DateTime // should work for DateTime
assert.sameValue(us.format(Temporal.PlainDateTime.from(t1)), "11/18/1976, 2:23:30 PM"); assert.sameValue(us.format(Temporal.PlainDateTime.from(t1)), "11/18/1976, 2:23:30 PM");
assert.sameValue(at.format(Temporal.PlainDateTime.from(t1)), "18.11.1976, 14:23:30"); assert.sameValue(at.format(Temporal.PlainDateTime.from(t1)), "18.11.1976, 14:23:30");
//should work for Time // should work for Time
assert.sameValue(us.format(Temporal.PlainTime.from(t1)), "2:23:30 PM"); assert.sameValue(us.format(Temporal.PlainTime.from(t1)), "2:23:30 PM");
assert.sameValue(at.format(Temporal.PlainTime.from(t1)), "14:23:30"); assert.sameValue(at.format(Temporal.PlainTime.from(t1)), "14:23:30");
//should work for Date // should work for Date
assert.sameValue(us.format(Temporal.PlainDate.from(t1)), "11/18/1976"); assert.sameValue(us.format(Temporal.PlainDate.from(t1)), "11/18/1976");
assert.sameValue(at.format(Temporal.PlainDate.from(t1)), "18.11.1976"); assert.sameValue(at.format(Temporal.PlainDate.from(t1)), "18.11.1976");
//should work for YearMonth // should work for YearMonth
var t = Temporal.PlainDate.from(t1); var t = Temporal.PlainDate.from(t1);
assert.sameValue(us.format(t.withCalendar(usCalendar).toPlainYearMonth()), "11/1976"); assert.sameValue(us.format(t.withCalendar(usCalendar).toPlainYearMonth()), "11/1976");
assert.sameValue(at.format(t.withCalendar(atCalendar).toPlainYearMonth()), "11.1976"); assert.sameValue(at.format(t.withCalendar(atCalendar).toPlainYearMonth()), "11.1976");
//should work for MonthDay // should work for MonthDay
var t = Temporal.PlainDate.from(t1); var t = Temporal.PlainDate.from(t1);
assert.sameValue(us.format(t.withCalendar(usCalendar).toPlainMonthDay()), "11/18"); assert.sameValue(us.format(t.withCalendar(usCalendar).toPlainMonthDay()), "11/18");
assert.sameValue(at.format(t.withCalendar(atCalendar).toPlainMonthDay()), "18.11."); assert.sameValue(at.format(t.withCalendar(atCalendar).toPlainMonthDay()), "18.11.");
//should not break legacy Date // should not break legacy Date
assert.sameValue(us.format(start), "12/29/1922"); assert.sameValue(us.format(start), "12/29/1922");
assert.sameValue(at.format(start), "30.12.1922"); assert.sameValue(at.format(start), "30.12.1922");
//should work for Instant // should work for Instant
assert.deepEqual(us.formatToParts(Temporal.Instant.from(t2)), [ assert.deepEqual(us.formatToParts(Temporal.Instant.from(t2)), [
{ {
type: "month", type: "month",
@ -189,7 +186,7 @@ assert.deepEqual(at.formatToParts(Temporal.Instant.from(t2)), [
value: "56" value: "56"
} }
]); ]);
//should work for ZonedDateTime // should work for ZonedDateTime
assert.deepEqual(us2.formatToParts(Temporal.ZonedDateTime.from(t2)), [ assert.deepEqual(us2.formatToParts(Temporal.ZonedDateTime.from(t2)), [
{ {
type: "month", type: "month",
@ -306,7 +303,7 @@ assert.deepEqual(at2.formatToParts(Temporal.ZonedDateTime.from(t2)), [
value: "GMT-5" value: "GMT-5"
} }
]); ]);
//should work for DateTime // should work for DateTime
assert.deepEqual(us.formatToParts(Temporal.PlainDateTime.from(t2)), [ assert.deepEqual(us.formatToParts(Temporal.PlainDateTime.from(t2)), [
{ {
type: "month", type: "month",
@ -407,7 +404,7 @@ assert.deepEqual(at.formatToParts(Temporal.PlainDateTime.from(t2)), [
value: "56" value: "56"
} }
]); ]);
//should work for Time // should work for Time
assert.deepEqual(us.formatToParts(Temporal.PlainTime.from(t2)), [ assert.deepEqual(us.formatToParts(Temporal.PlainTime.from(t2)), [
{ {
type: "hour", type: "hour",
@ -460,7 +457,7 @@ assert.deepEqual(at.formatToParts(Temporal.PlainTime.from(t2)), [
value: "56" value: "56"
} }
]); ]);
//should work for Date // should work for Date
assert.deepEqual(us.formatToParts(Temporal.PlainDate.from(t2)), [ assert.deepEqual(us.formatToParts(Temporal.PlainDate.from(t2)), [
{ {
type: "month", type: "month",
@ -505,7 +502,7 @@ assert.deepEqual(at.formatToParts(Temporal.PlainDate.from(t2)), [
value: "2020" value: "2020"
} }
]); ]);
//should work for YearMonth // should work for YearMonth
var t = Temporal.PlainDate.from(t2); var t = Temporal.PlainDate.from(t2);
assert.deepEqual(us.formatToParts(t.withCalendar(usCalendar).toPlainYearMonth()), [ assert.deepEqual(us.formatToParts(t.withCalendar(usCalendar).toPlainYearMonth()), [
{ {
@ -535,7 +532,7 @@ assert.deepEqual(at.formatToParts(t.withCalendar(atCalendar).toPlainYearMonth())
value: "2020" value: "2020"
} }
]); ]);
//should work for MonthDay // should work for MonthDay
var t = Temporal.PlainDate.from(t2); var t = Temporal.PlainDate.from(t2);
assert.deepEqual(us.formatToParts(t.withCalendar(usCalendar).toPlainMonthDay()), [ assert.deepEqual(us.formatToParts(t.withCalendar(usCalendar).toPlainMonthDay()), [
{ {
@ -569,7 +566,7 @@ assert.deepEqual(at.formatToParts(t.withCalendar(atCalendar).toPlainMonthDay()),
value: "." value: "."
} }
]); ]);
//should not break legacy Date // should not break legacy Date
assert.deepEqual(us.formatToParts(end), [ assert.deepEqual(us.formatToParts(end), [
{ {
type: "month", type: "month",
@ -614,55 +611,92 @@ assert.deepEqual(at.formatToParts(end), [
value: "1991" value: "1991"
} }
]); ]);
//formatRange // formatRange
//should work for Instant // should work for Instant
assert.sameValue(us.formatRange(Temporal.Instant.from(t1), Temporal.Instant.from(t2)), "11/18/1976, 9:23:30 AM \u2013 2/20/2020, 3:44:56 PM"); assert.sameValue(
assert.sameValue(at.formatRange(Temporal.Instant.from(t1), Temporal.Instant.from(t2)), "18.11.1976, 15:23:30 \u2013 20.2.2020, 21:44:56"); us.formatRange(Temporal.Instant.from(t1), Temporal.Instant.from(t2)),
"11/18/1976, 9:23:30 AM \u2013 2/20/2020, 3:44:56 PM"
);
assert.sameValue(
at.formatRange(Temporal.Instant.from(t1), Temporal.Instant.from(t2)),
"18.11.1976, 15:23:30 \u2013 20.2.2020, 21:44:56"
);
//should work for ZonedDateTime // should work for ZonedDateTime
var zdt1 = Temporal.ZonedDateTime.from(t1); var zdt1 = Temporal.ZonedDateTime.from(t1);
var zdt2 = Temporal.ZonedDateTime.from(t2).withTimeZone(zdt1.timeZone); var zdt2 = Temporal.ZonedDateTime.from(t2).withTimeZone(zdt1.timeZone);
assert.sameValue(us2.formatRange(zdt1, zdt2), "11/18/1976, 2:23:30 PM UTC \u2013 2/20/2020, 8:44:56 PM UTC"); assert.sameValue(us2.formatRange(zdt1, zdt2), "11/18/1976, 2:23:30 PM UTC \u2013 2/20/2020, 8:44:56 PM UTC");
assert.sameValue(at2.formatRange(zdt1, zdt2), "18.11.1976, 14:23:30 UTC \u2013 20.2.2020, 20:44:56 UTC"); assert.sameValue(at2.formatRange(zdt1, zdt2), "18.11.1976, 14:23:30 UTC \u2013 20.2.2020, 20:44:56 UTC");
//should work for DateTime // should work for DateTime
assert.sameValue(us.formatRange(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2)), "11/18/1976, 2:23:30 PM \u2013 2/20/2020, 3:44:56 PM"); assert.sameValue(
assert.sameValue(at.formatRange(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2)), "18.11.1976, 14:23:30 \u2013 20.2.2020, 15:44:56"); us.formatRange(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2)),
"11/18/1976, 2:23:30 PM \u2013 2/20/2020, 3:44:56 PM"
);
assert.sameValue(
at.formatRange(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2)),
"18.11.1976, 14:23:30 \u2013 20.2.2020, 15:44:56"
);
//should work for Time // should work for Time
assert.sameValue(us.formatRange(Temporal.PlainTime.from(t1), Temporal.PlainTime.from(t2)), "2:23:30 PM \u2013 3:44:56 PM"); assert.sameValue(
us.formatRange(Temporal.PlainTime.from(t1), Temporal.PlainTime.from(t2)),
"2:23:30 PM \u2013 3:44:56 PM"
);
assert.sameValue(at.formatRange(Temporal.PlainTime.from(t1), Temporal.PlainTime.from(t2)), "14:23:30 \u2013 15:44:56"); assert.sameValue(at.formatRange(Temporal.PlainTime.from(t1), Temporal.PlainTime.from(t2)), "14:23:30 \u2013 15:44:56");
//should work for Date // should work for Date
assert.sameValue(us.formatRange(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2)), "11/18/1976 \u2013 2/20/2020"); assert.sameValue(
assert.sameValue(at.formatRange(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2)), "18.11.1976 \u2013 20.02.2020"); us.formatRange(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2)),
"11/18/1976 \u2013 2/20/2020"
);
assert.sameValue(
at.formatRange(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2)),
"18.11.1976 \u2013 20.02.2020"
);
//should work for YearMonth // should work for YearMonth
var date1 = Temporal.PlainDate.from(t1); var date1 = Temporal.PlainDate.from(t1);
var date2 = Temporal.PlainDate.from(t2); var date2 = Temporal.PlainDate.from(t2);
assert.sameValue(us.formatRange(date1.withCalendar(usCalendar).toPlainYearMonth(), date2.withCalendar(usCalendar).toPlainYearMonth()), "11/1976 \u2013 2/2020"); assert.sameValue(
assert.sameValue(at.formatRange(date1.withCalendar(atCalendar).toPlainYearMonth(), date2.withCalendar(atCalendar).toPlainYearMonth()), "11.1976 \u2013 02.2020"); us.formatRange(date1.withCalendar(usCalendar).toPlainYearMonth(), date2.withCalendar(usCalendar).toPlainYearMonth()),
"11/1976 \u2013 2/2020"
);
assert.sameValue(
at.formatRange(date1.withCalendar(atCalendar).toPlainYearMonth(), date2.withCalendar(atCalendar).toPlainYearMonth()),
"11.1976 \u2013 02.2020"
);
//should work for MonthDay // should work for MonthDay
var date1 = Temporal.PlainDate.from(t1); var date1 = Temporal.PlainDate.from(t1);
var date2 = Temporal.PlainDate.from(t2); var date2 = Temporal.PlainDate.from(t2);
assert.sameValue(us.formatRange(date2.withCalendar(usCalendar).toPlainMonthDay(), date1.withCalendar(usCalendar).toPlainMonthDay()), "2/20 \u2013 11/18"); assert.sameValue(
assert.sameValue(at.formatRange(date2.withCalendar(atCalendar).toPlainMonthDay(), date1.withCalendar(atCalendar).toPlainMonthDay()), "20.02. \u2013 18.11."); us.formatRange(date2.withCalendar(usCalendar).toPlainMonthDay(), date1.withCalendar(usCalendar).toPlainMonthDay()),
"2/20 \u2013 11/18"
);
assert.sameValue(
at.formatRange(date2.withCalendar(atCalendar).toPlainMonthDay(), date1.withCalendar(atCalendar).toPlainMonthDay()),
"20.02. \u2013 18.11."
);
//should not break legacy Date // should not break legacy Date
assert.sameValue(us.formatRange(start, end), "12/29/1922 \u2013 12/25/1991"); assert.sameValue(us.formatRange(start, end), "12/29/1922 \u2013 12/25/1991");
assert.sameValue(at.formatRange(start, end), "30.12.1922 \u2013 26.12.1991"); assert.sameValue(at.formatRange(start, end), "30.12.1922 \u2013 26.12.1991");
//should throw a TypeError when called with dissimilar types", () => assert.throws(TypeError, () => us.formatRange(Temporal.Instant.from(t1), Temporal.PlainDateTime.from(t2)))); // should throw a TypeError when called with dissimilar types", () => assert.throws(TypeError, () => us.formatRange(Temporal.Instant.from(t1), Temporal.PlainDateTime.from(t2))));
//should throw a RangeError when called with different calendars // should throw a RangeError when called with different calendars
assert.throws(RangeError, () => us.formatRange(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2).withCalendar("japanese"))); assert.throws(RangeError, () =>
assert.throws(RangeError, () => us.formatRange(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2).withCalendar("japanese"))); us.formatRange(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2).withCalendar("japanese"))
);
assert.throws(RangeError, () =>
us.formatRange(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2).withCalendar("japanese"))
);
//throws for two ZonedDateTimes with different time zones // throws for two ZonedDateTimes with different time zones
assert.throws(RangeError, () => us2.formatRange(Temporal.ZonedDateTime.from(t1), Temporal.ZonedDateTime.from(t2))); assert.throws(RangeError, () => us2.formatRange(Temporal.ZonedDateTime.from(t1), Temporal.ZonedDateTime.from(t2)));
//formatRangeToParts // formatRangeToParts
//should work for Instant // should work for Instant
assert.deepEqual(us.formatRangeToParts(Temporal.Instant.from(t1), Temporal.Instant.from(t2)), [ assert.deepEqual(us.formatRangeToParts(Temporal.Instant.from(t1), Temporal.Instant.from(t2)), [
{ {
type: "month", type: "month",
@ -918,7 +952,7 @@ assert.deepEqual(at.formatRangeToParts(Temporal.Instant.from(t1), Temporal.Insta
} }
]); ]);
//should work for ZonedDateTime // should work for ZonedDateTime
var zdt1 = Temporal.ZonedDateTime.from(t1); var zdt1 = Temporal.ZonedDateTime.from(t1);
var zdt2 = Temporal.ZonedDateTime.from(t2).withTimeZone(zdt1.timeZone); var zdt2 = Temporal.ZonedDateTime.from(t2).withTimeZone(zdt1.timeZone);
assert.deepEqual(us2.formatRangeToParts(zdt1, zdt2), [ assert.deepEqual(us2.formatRangeToParts(zdt1, zdt2), [
@ -1215,7 +1249,7 @@ assert.deepEqual(at2.formatRangeToParts(zdt1, zdt2), [
source: "endRange" source: "endRange"
} }
]); ]);
//should work for DateTime // should work for DateTime
assert.deepEqual(us.formatRangeToParts(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2)), [ assert.deepEqual(us.formatRangeToParts(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2)), [
{ {
type: "month", type: "month",
@ -1470,7 +1504,7 @@ assert.deepEqual(at.formatRangeToParts(Temporal.PlainDateTime.from(t1), Temporal
source: "endRange" source: "endRange"
} }
]); ]);
//should work for Time // should work for Time
assert.deepEqual(us.formatRangeToParts(Temporal.PlainTime.from(t1), Temporal.PlainTime.from(t2)), [ assert.deepEqual(us.formatRangeToParts(Temporal.PlainTime.from(t1), Temporal.PlainTime.from(t2)), [
{ {
type: "hour", type: "hour",
@ -1605,7 +1639,7 @@ assert.deepEqual(at.formatRangeToParts(Temporal.PlainTime.from(t1), Temporal.Pla
source: "endRange" source: "endRange"
} }
]); ]);
//should work for Date // should work for Date
assert.deepEqual(us.formatRangeToParts(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2)), [ assert.deepEqual(us.formatRangeToParts(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2)), [
{ {
type: "month", type: "month",
@ -1720,166 +1754,190 @@ assert.deepEqual(at.formatRangeToParts(Temporal.PlainDate.from(t1), Temporal.Pla
source: "endRange" source: "endRange"
} }
]); ]);
//should work for YearMonth // should work for YearMonth
var date1 = Temporal.PlainDate.from(t1); var date1 = Temporal.PlainDate.from(t1);
var date2 = Temporal.PlainDate.from(t2); var date2 = Temporal.PlainDate.from(t2);
assert.deepEqual(us.formatRangeToParts(date1.withCalendar(usCalendar).toPlainYearMonth(), date2.withCalendar(usCalendar).toPlainYearMonth()), [ assert.deepEqual(
{ us.formatRangeToParts(
type: "month", date1.withCalendar(usCalendar).toPlainYearMonth(),
value: "11", date2.withCalendar(usCalendar).toPlainYearMonth()
source: "startRange" ),
}, [
{ {
type: "literal", type: "month",
value: "/", value: "11",
source: "startRange" source: "startRange"
}, },
{ {
type: "year", type: "literal",
value: "1976", value: "/",
source: "startRange" source: "startRange"
}, },
{ {
type: "literal", type: "year",
value: " \u2013 ", value: "1976",
source: "shared" source: "startRange"
}, },
{ {
type: "month", type: "literal",
value: "2", value: " \u2013 ",
source: "endRange" source: "shared"
}, },
{ {
type: "literal", type: "month",
value: "/", value: "2",
source: "endRange" source: "endRange"
}, },
{ {
type: "year", type: "literal",
value: "2020", value: "/",
source: "endRange" source: "endRange"
} },
]); {
assert.deepEqual(at.formatRangeToParts(date1.withCalendar(atCalendar).toPlainYearMonth(), date2.withCalendar(atCalendar).toPlainYearMonth()), [ type: "year",
{ value: "2020",
type: "month", source: "endRange"
value: "11", }
source: "startRange" ]
}, );
{ assert.deepEqual(
type: "literal", at.formatRangeToParts(
value: ".", date1.withCalendar(atCalendar).toPlainYearMonth(),
source: "startRange" date2.withCalendar(atCalendar).toPlainYearMonth()
}, ),
{ [
type: "year", {
value: "1976", type: "month",
source: "startRange" value: "11",
}, source: "startRange"
{ },
type: "literal", {
value: " \u2013 ", type: "literal",
source: "shared" value: ".",
}, source: "startRange"
{ },
type: "month", {
value: "02", type: "year",
source: "endRange" value: "1976",
}, source: "startRange"
{ },
type: "literal", {
value: ".", type: "literal",
source: "endRange" value: " \u2013 ",
}, source: "shared"
{ },
type: "year", {
value: "2020", type: "month",
source: "endRange" value: "02",
} source: "endRange"
]); },
//should work for MonthDay {
type: "literal",
value: ".",
source: "endRange"
},
{
type: "year",
value: "2020",
source: "endRange"
}
]
);
// should work for MonthDay
var date1 = Temporal.PlainDate.from(t1); var date1 = Temporal.PlainDate.from(t1);
var date2 = Temporal.PlainDate.from(t2); var date2 = Temporal.PlainDate.from(t2);
assert.deepEqual(us.formatRangeToParts(date2.withCalendar(usCalendar).toPlainMonthDay(), date1.withCalendar(usCalendar).toPlainMonthDay()), [ assert.deepEqual(
{ us.formatRangeToParts(
type: "month", date2.withCalendar(usCalendar).toPlainMonthDay(),
value: "2", date1.withCalendar(usCalendar).toPlainMonthDay()
source: "startRange" ),
}, [
{ {
type: "literal", type: "month",
value: "/", value: "2",
source: "startRange" source: "startRange"
}, },
{ {
type: "day", type: "literal",
value: "20", value: "/",
source: "startRange" source: "startRange"
}, },
{ {
type: "literal", type: "day",
value: " \u2013 ", value: "20",
source: "shared" source: "startRange"
}, },
{ {
type: "month", type: "literal",
value: "11", value: " \u2013 ",
source: "endRange" source: "shared"
}, },
{ {
type: "literal", type: "month",
value: "/", value: "11",
source: "endRange" source: "endRange"
}, },
{ {
type: "day", type: "literal",
value: "18", value: "/",
source: "endRange" source: "endRange"
} },
]); {
assert.deepEqual(at.formatRangeToParts(date2.withCalendar(atCalendar).toPlainMonthDay(), date1.withCalendar(atCalendar).toPlainMonthDay()), [ type: "day",
{ value: "18",
type: "day", source: "endRange"
value: "20", }
source: "startRange" ]
}, );
{ assert.deepEqual(
type: "literal", at.formatRangeToParts(
value: ".", date2.withCalendar(atCalendar).toPlainMonthDay(),
source: "startRange" date1.withCalendar(atCalendar).toPlainMonthDay()
}, ),
{ [
type: "month", {
value: "02", type: "day",
source: "startRange" value: "20",
}, source: "startRange"
{ },
type: "literal", {
value: ". \u2013 ", type: "literal",
source: "shared" value: ".",
}, source: "startRange"
{ },
type: "day", {
value: "18", type: "month",
source: "endRange" value: "02",
}, source: "startRange"
{ },
type: "literal", {
value: ".", type: "literal",
source: "endRange" value: ". \u2013 ",
}, source: "shared"
{ },
type: "month", {
value: "11", type: "day",
source: "endRange" value: "18",
}, source: "endRange"
{ },
type: "literal", {
value: ".", type: "literal",
source: "shared" value: ".",
} source: "endRange"
]); },
//should not break legacy Date {
type: "month",
value: "11",
source: "endRange"
},
{
type: "literal",
value: ".",
source: "shared"
}
]
);
// should not break legacy Date
assert.deepEqual(us.formatRangeToParts(start, end), [ assert.deepEqual(us.formatRangeToParts(start, end), [
{ {
type: "month", type: "month",
@ -1994,10 +2052,16 @@ assert.deepEqual(at.formatRangeToParts(start, end), [
source: "endRange" source: "endRange"
} }
]); ]);
//should throw a TypeError when called with dissimilar types // should throw a TypeError when called with dissimilar types
assert.throws(TypeError, () => at.formatRangeToParts(Temporal.Instant.from(t1), Temporal.PlainDateTime.from(t2))); assert.throws(TypeError, () => at.formatRangeToParts(Temporal.Instant.from(t1), Temporal.PlainDateTime.from(t2)));
//should throw a RangeError when called with different calendars // should throw a RangeError when called with different calendars
assert.throws(RangeError, () => at.formatRangeToParts(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2).withCalendar("japanese"))); assert.throws(RangeError, () =>
assert.throws(RangeError, () => at.formatRangeToParts(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2).withCalendar("japanese"))); at.formatRangeToParts(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2).withCalendar("japanese"))
//throws for two ZonedDateTimes with different time zones );
assert.throws(RangeError, () => us2.formatRangeToParts(Temporal.ZonedDateTime.from(t1), Temporal.ZonedDateTime.from(t2))); assert.throws(RangeError, () =>
at.formatRangeToParts(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2).withCalendar("japanese"))
);
// throws for two ZonedDateTimes with different time zones
assert.throws(RangeError, () =>
us2.formatRangeToParts(Temporal.ZonedDateTime.from(t1), Temporal.ZonedDateTime.from(t2))
);

12
test/staging/Intl402/Temporal/old/datetime-toLocaleString.js
View File

@ -8,21 +8,21 @@ features: [Temporal]
---*/ ---*/
function maybeGetWeekdayOnlyFormat() { function maybeGetWeekdayOnlyFormat() {
const fmt = new Intl.DateTimeFormat('en', { weekday: 'long', timeZone: 'Europe/Vienna' }); const fmt = new Intl.DateTimeFormat("en", { weekday: "long", timeZone: "Europe/Vienna" });
if ( if (
['era', 'year', 'month', 'day', 'hour', 'minute', 'second', 'timeZoneName'].some( ["era", "year", "month", "day", "hour", "minute", "second", "timeZoneName"].some(
(prop) => prop in fmt.resolvedOptions() (prop) => prop in fmt.resolvedOptions()
) )
) { ) {
//no weekday-only format available // no weekday-only format available
return null; return null;
} }
return fmt; return fmt;
} }
var datetime = Temporal.PlainDateTime.from("1976-11-18T15:23:30"); var datetime = Temporal.PlainDateTime.from("1976-11-18T15:23:30");
assert.sameValue(`${ datetime.toLocaleString("en", { timeZone: "America/New_York" }) }`, "11/18/1976, 3:23:30 PM") assert.sameValue(`${datetime.toLocaleString("en", { timeZone: "America/New_York" })}`, "11/18/1976, 3:23:30 PM");
assert.sameValue(`${ datetime.toLocaleString("de", { timeZone: "Europe/Vienna" }) }`, "18.11.1976, 15:23:30") assert.sameValue(`${datetime.toLocaleString("de", { timeZone: "Europe/Vienna" })}`, "18.11.1976, 15:23:30");
var fmt = maybeGetWeekdayOnlyFormat(); var fmt = maybeGetWeekdayOnlyFormat();
if (fmt) assert.sameValue(fmt.format(datetime), "Thursday"); if (fmt) assert.sameValue(fmt.format(datetime), "Thursday");
@ -31,7 +31,7 @@ assert.sameValue(datetime.toLocaleString("en", { timeZoneName: "long" }), "11/18
// should use compatible disambiguation option // should use compatible disambiguation option
var dstStart = new Temporal.PlainDateTime(2020, 3, 8, 2, 30); var dstStart = new Temporal.PlainDateTime(2020, 3, 8, 2, 30);
assert.sameValue(`${ dstStart.toLocaleString("en", { timeZone: "America/Los_Angeles" }) }`, "3/8/2020, 3:30:00 AM"); assert.sameValue(`${dstStart.toLocaleString("en", { timeZone: "America/Los_Angeles" })}`, "3/8/2020, 3:30:00 AM");
// works when the object's calendar is the same as the locale's calendar // works when the object's calendar is the same as the locale's calendar
var dt = Temporal.PlainDateTime.from({ var dt = Temporal.PlainDateTime.from({

13
test/staging/Intl402/Temporal/old/instant-toLocaleString.js
View File

@ -8,24 +8,23 @@ features: [Temporal]
---*/ ---*/
function maybeGetWeekdayOnlyFormat() { function maybeGetWeekdayOnlyFormat() {
const fmt = new Intl.DateTimeFormat('en', { weekday: 'long', timeZone: 'Europe/Vienna' }); const fmt = new Intl.DateTimeFormat("en", { weekday: "long", timeZone: "Europe/Vienna" });
if ( if (
['era', 'year', 'month', 'day', 'hour', 'minute', 'second', 'timeZoneName'].some( ["era", "year", "month", "day", "hour", "minute", "second", "timeZoneName"].some(
(prop) => prop in fmt.resolvedOptions() (prop) => prop in fmt.resolvedOptions()
) )
) { ) {
//no weekday-only format available // no weekday-only format available
return null; return null;
} }
return fmt; return fmt;
} }
var instant = Temporal.Instant.from("1976-11-18T14:23:30Z"); var instant = Temporal.Instant.from("1976-11-18T14:23:30Z");
assert.sameValue(`${ instant.toLocaleString("en", { timeZone: "America/New_York" }) }`, "11/18/1976, 9:23:30 AM") assert.sameValue(`${instant.toLocaleString("en", { timeZone: "America/New_York" })}`, "11/18/1976, 9:23:30 AM");
assert.sameValue(`${ instant.toLocaleString("de", { timeZone: "Europe/Vienna" }) }`, "18.11.1976, 15:23:30") assert.sameValue(`${instant.toLocaleString("de", { timeZone: "Europe/Vienna" })}`, "18.11.1976, 15:23:30");
var fmt = maybeGetWeekdayOnlyFormat(); var fmt = maybeGetWeekdayOnlyFormat();
if (fmt) if (fmt) assert.sameValue(fmt.format(instant), "Thursday");
assert.sameValue(fmt.format(instant), "Thursday");
// outputs timeZoneName if requested // outputs timeZoneName if requested
var str = instant.toLocaleString("en", { var str = instant.toLocaleString("en", {

4
test/staging/Intl402/Temporal/old/time-toLocaleString.js
View File

@ -8,8 +8,8 @@ features: [Temporal]
---*/ ---*/
var time = Temporal.PlainTime.from("1976-11-18T15:23:30"); var time = Temporal.PlainTime.from("1976-11-18T15:23:30");
assert.sameValue(`${ time.toLocaleString("en", { timeZone: "America/New_York" }) }`, "3:23:30 PM") assert.sameValue(`${time.toLocaleString("en", { timeZone: "America/New_York" })}`, "3:23:30 PM");
assert.sameValue(`${ time.toLocaleString("de", { timeZone: "Europe/Vienna" }) }`, "15:23:30") assert.sameValue(`${time.toLocaleString("de", { timeZone: "Europe/Vienna" })}`, "15:23:30");
// should ignore units not in the data type // should ignore units not in the data type
assert.sameValue(time.toLocaleString("en", { timeZoneName: "long" }), "3:23:30 PM"); assert.sameValue(time.toLocaleString("en", { timeZoneName: "long" }), "3:23:30 PM");

14
test/staging/Intl402/Temporal/old/yearmonth-toLocaleString.js
View File

@ -1,4 +1,3 @@
// Copyright (C) 2018 Bloomberg LP. All rights reserved. // Copyright (C) 2018 Bloomberg LP. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file. // This code is governed by the BSD license found in the LICENSE file.
@ -14,11 +13,14 @@ var yearmonth = Temporal.PlainYearMonth.from({
month: 11, month: 11,
calendar calendar
}); });
assert.sameValue(`${ yearmonth.toLocaleString("en", { timeZone: "America/New_York" }) }`, "11/1976") assert.sameValue(`${yearmonth.toLocaleString("en", { timeZone: "America/New_York" })}`, "11/1976");
assert.sameValue(`${ yearmonth.toLocaleString("de", { assert.sameValue(
timeZone: "Europe/Vienna", `${yearmonth.toLocaleString("de", {
calendar timeZone: "Europe/Vienna",
}) }`, "11.1976") calendar
})}`,
"11.1976"
);
// should ignore units not in the data type // should ignore units not in the data type
assert.sameValue(yearmonth.toLocaleString("en", { timeZoneName: "long" }), "11/1976"); assert.sameValue(yearmonth.toLocaleString("en", { timeZoneName: "long" }), "11/1976");

19
test/staging/Intl402/Temporal/old/zoneddatetime-toLocaleString.js
View File

@ -8,27 +8,30 @@ features: [Temporal]
---*/ ---*/
function maybeGetWeekdayOnlyFormat() { function maybeGetWeekdayOnlyFormat() {
const fmt = new Intl.DateTimeFormat('en', { weekday: 'long', timeZone: 'Europe/Vienna' }); const fmt = new Intl.DateTimeFormat("en", { weekday: "long", timeZone: "Europe/Vienna" });
if ( if (
['era', 'year', 'month', 'day', 'hour', 'minute', 'second', 'timeZoneName'].some( ["era", "year", "month", "day", "hour", "minute", "second", "timeZoneName"].some(
(prop) => prop in fmt.resolvedOptions() (prop) => prop in fmt.resolvedOptions()
) )
) { ) {
//no weekday-only format available // no weekday-only format available
return null; return null;
} }
return fmt; return fmt;
} }
var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30+01:00[Europe/Vienna]"); var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30+01:00[Europe/Vienna]");
assert.sameValue(zdt.toLocaleString("en"), "11/18/1976, 3:23:30 PM GMT+1") assert.sameValue(zdt.toLocaleString("en"), "11/18/1976, 3:23:30 PM GMT+1");
assert.sameValue(zdt.toLocaleString("de"), "18.11.1976, 15:23:30 MEZ") assert.sameValue(zdt.toLocaleString("de"), "18.11.1976, 15:23:30 MEZ");
const fmt = maybeGetWeekdayOnlyFormat(); const fmt = maybeGetWeekdayOnlyFormat();
//uses only the options in resolvedOptions // uses only the options in resolvedOptions
if (fmt) assert.sameValue(fmt.format(zdt), 'Thursday'); if (fmt) assert.sameValue(fmt.format(zdt), "Thursday");
// can override the style of the time zone name // can override the style of the time zone name
assert.sameValue(zdt.toLocaleString("en", { timeZoneName: "long" }), "11/18/1976, 3:23:30 PM Central European Standard Time"); assert.sameValue(
zdt.toLocaleString("en", { timeZoneName: "long" }),
"11/18/1976, 3:23:30 PM Central European Standard Time"
);
// works if the time zone given in options agrees with the object's time zone // works if the time zone given in options agrees with the object's time zone
assert.sameValue(zdt.toLocaleString("en", { timeZone: "Europe/Vienna" }), "11/18/1976, 3:23:30 PM GMT+1"); assert.sameValue(zdt.toLocaleString("en", { timeZone: "Europe/Vienna" }), "11/18/1976, 3:23:30 PM GMT+1");