Merge branch 'main' into dasaria/await-dictionary-keyed-runtime-tests

Author: danialasaria

test/intl402/DateTimeFormat/prototype/format/temporal-objects-format-weekday-long.js

@@ -0,0 +1,37 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-datetime-format-functions
+description: datetime.toLocaleString()
+features: [Temporal]
+locale: [en-US]
+---*/
+
+function maybeGetWeekdayOnlyFormat() {
+  const fmt = new Intl.DateTimeFormat("en-US", { weekday: "long", timeZone: "+00:00" });
+  const resolvedOptions = fmt.resolvedOptions();
+  if (
+    ["era", "year", "month", "day", "hour", "minute", "second", "timeZoneName"].some(
+      (prop) => prop in resolvedOptions
+    )
+  ) {
+    // no weekday-only format available
+    return null;
+  }
+  return fmt;
+}
+
+const fmt = maybeGetWeekdayOnlyFormat();
+if (fmt) {
+  const expectedWeekday = fmt.format(new Date("1976-11-18T15:23:30"));
+
+  const datetime = Temporal.PlainDateTime.from("1976-11-18T15:23:30");
+  assert.sameValue(fmt.format(datetime), expectedWeekday);
+
+  const date = Temporal.PlainDate.from("1976-11-18T15:23:30");
+  assert.sameValue(fmt.format(date), expectedWeekday);
+
+  const instant = Temporal.Instant.from("1976-11-18T14:23:30Z");
+  assert.sameValue(fmt.format(instant), expectedWeekday);
+}

test/intl402/DateTimeFormat/prototype/format/temporal-objects-no-time-clip.js

@@ -0,0 +1,78 @@
+// Copyright (C) 2026 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-partitiondatetimepattern
+description: >
+  TimeClip is not applied for Temporal plain objects.
+info: |
+  HandleDateTimeTemporalDate ( dateTimeFormat, temporalDate )
+    ...
+    2. Let isoDateTime be CombineISODateAndTimeRecord(temporalDate.[[ISODate]], NoonTimeRecord()).
+    3. Let epochNs be GetUTCEpochNanoseconds(isoDateTime).
+    ...
+    6. Return Value Format Record { [[Format]]: format, [[EpochNanoseconds]]: epochNs, [[IsPlain]]: true  }.
+
+  HandleDateTimeTemporalDateTime ( dateTimeFormat, dateTime )
+    ...
+    2. Let epochNs be GetUTCEpochNanoseconds(dateTime.[[ISODateTime]]).
+    ...
+    4. Return Value Format Record { [[Format]]: format, [[EpochNanoseconds]]: epochNs, [[IsPlain]]: true  }.
+
+  HandleDateTimeTemporalYearMonth ( dateTimeFormat, temporalYearMonth )
+    ...
+    2. Let isoDateTime be CombineISODateAndTimeRecord(temporalYearMonth.[[ISODate]], NoonTimeRecord()).
+    3. Let epochNs be GetUTCEpochNanoseconds(isoDateTime).
+    ...
+    6. Return Value Format Record { [[Format]]: format, [[EpochNanoseconds]]: epochNs, [[IsPlain]]: true  }.
+
+  PartitionDateTimePattern ( dateTimeFormat, x )
+    1. Let formatRecord be ? HandleDateTimeValue(dateTimeFormat, x).
+    2. Let epochNanoseconds be formatRecord.[[EpochNanoseconds]].
+    ...
+    6. Let result be FormatDateTimePattern(dateTimeFormat, format, pattern, epochNanoseconds, formatRecord.[[IsPlain]]).
+    7. Return result.
+features: [Temporal]
+locale: [en]
+---*/
+
+// Test with Temporal default calendar "iso8601" and additionally "gregory".
+var calendars = ["iso8601", "gregory"];
+
+for (var calendar of calendars) {
+  var dtf = new Intl.DateTimeFormat("en", {calendar});
+
+  // Minimum plain date value.
+  var minDate = dtf.format(new Temporal.PlainDate(-271821, 4, 19, calendar));
+  assert(minDate.includes("-271821") || minDate.includes("271822"), "minDate includes year");
+  assert(minDate.includes("4"), "minDate includes month");
+  assert(minDate.includes("19"), "minDate includes day");
+
+  // Maximum plain date value.
+  var maxDate = dtf.format(new Temporal.PlainDate(275760, 9, 13, calendar));
+  assert(maxDate.includes("275760"), "maxDate includes year");
+  assert(maxDate.includes("9"), "maxDate includes month");
+  assert(maxDate.includes("13"), "maxDate includes day");
+
+  // Minimum plain date-time value.
+  var minDateTime = dtf.format(new Temporal.PlainDateTime(-271821, 4, 19, 0, 0, 0, 0, 0, 1, calendar));
+  assert(minDateTime.includes("-271821") || minDate.includes("271822"), "minDateTime includes year");
+  assert(minDateTime.includes("4"), "minDateTime includes month");
+  assert(minDateTime.includes("19"), "minDateTime includes day");
+
+  // Maximum plain date-time value.
+  var maxDateTime = dtf.format(new Temporal.PlainDateTime(275760, 9, 13, 23, 59, 59, 999, 999, 999, calendar));
+  assert(maxDateTime.includes("275760"), "maxDateTime includes year");
+  assert(maxDateTime.includes("9"), "maxDateTime includes month");
+  assert(maxDateTime.includes("13"), "maxDateTime includes day");
+
+  // Minimum plain year-month value.
+  var minYearMonth = dtf.format(new Temporal.PlainYearMonth(-271821, 4, calendar));
+  assert(minYearMonth.includes("-271821") || minDate.includes("271822"), "minYearMonth includes year");
+  assert(minYearMonth.includes("4"), "minYearMonth includes month");
+
+  // Maximum plain year-month value.
+  var maxYearMonth = dtf.format(new Temporal.PlainYearMonth(275760, 9, calendar));
+  assert(maxYearMonth.includes("275760"), "maxYearMonth includes year");
+  assert(maxYearMonth.includes("9"), "maxYearMonth includes month");
+}

test/intl402/Temporal/Instant/prototype/toLocaleString/basic.js

@@ -0,0 +1,83 @@
+// 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.prototype.tolocalestring
+description: Basic tests for Temporal.Instant.toLocaleString
+info: |
+    Temporal.Instant.prototype.toLocaleString ( [ locales [ , options ] ] )
+     ...
+    4. Return ? FormatDateTime(dateFormat, instant).
+    ...
+
+    FormatDateTime ( dateTimeFormat, x )
+    1. Let parts be ? PartitionDateTimePattern(dateTimeFormat, x).
+    2. Let result be the empty String.
+    3. For each Record { [[Type]], [[Value]] } part of parts, do
+        a. Set result to the string-concatenation of result and part.[[Value]].
+    4. Return result.
+
+    FormatDateTimeToParts ( dateTimeFormat, x )
+    1. Let parts be ? PartitionDateTimePattern(dateTimeFormat, x).
+    2. Let result be ! ArrayCreate(0).
+    3. Let n be 0.
+    4. For each Record { [[Type]], [[Value]] } part of parts, do
+           a. Let O be OrdinaryObjectCreate(%Object.prototype%).
+           b. Perform ! CreateDataPropertyOrThrow(O, "type", part.[[Type]]).
+           c. Perform ! CreateDataPropertyOrThrow(O, "value", part.[[Value]]).
+           d. Perform ! CreateDataPropertyOrThrow(result, ! ToString(𝔽(n)), O).
+           e. Increment n by 1.
+    5. Return result.
+features: [Temporal]
+locale: [en-US, de-AT]
+---*/
+
+function findPart(parts, expectedType) {
+  return parts.find(({ type }) => type === expectedType).value;
+}
+
+const instant = Temporal.Instant.from("1976-11-18T14:23:30Z");
+
+const dtfNY = new Intl.DateTimeFormat("en-US", { timeZone: "America/New_York" });
+assert.sameValue(
+  instant.toLocaleString("en-US", { timeZone: "America/New_York" }),
+  dtfNY.format(instant)
+);
+
+const partsNY = dtfNY.formatToParts(instant);
+const yearPartNY = findPart(partsNY, "year");
+const monthPartNY = findPart(partsNY, "month");
+const dayPartNY = findPart(partsNY, "day");
+const hourPartNY = findPart(partsNY, "hour");
+const minutePartNY = findPart(partsNY, "minute");
+const secondPartNY = findPart(partsNY, "second");
+const resultNY = instant.toLocaleString("en-US", { timeZone: "America/New_York" });
+assert(partsNY.some(part => part.type === "dayPeriod"), "en-US locale has a 12-hour format");
+assert(resultNY.includes(yearPartNY), "en-US locale string has a year part");
+assert(resultNY.includes(monthPartNY), "en-US locale string has a month part");
+assert(resultNY.includes(dayPartNY), "en-US locale string has a day part");
+assert(resultNY.includes(hourPartNY), "en-US locale string has an hour part");
+assert(resultNY.includes(minutePartNY), "en-US locale string has a minute part");
+assert(resultNY.includes(secondPartNY), "en-US locale string has a second part");
+
+const dtfVienna = new Intl.DateTimeFormat("de-AT", { timeZone: "Europe/Vienna" });
+assert.sameValue(
+  instant.toLocaleString("de-AT", { timeZone: "Europe/Vienna" }),
+  dtfVienna.format(instant)
+);
+
+const partsVienna = dtfVienna.formatToParts(instant);
+const yearPartVienna = findPart(partsVienna, "year");
+const monthPartVienna = findPart(partsVienna, "month");
+const dayPartVienna = findPart(partsVienna, "day");
+const hourPartVienna = findPart(partsVienna, "hour");
+const minutePartVienna = findPart(partsVienna, "minute");
+const secondPartVienna = findPart(partsVienna, "second");
+const resultVienna = instant.toLocaleString("de-AT", { timeZone: "Europe/Vienna" });
+assert(!partsVienna.some(part => part.type === "dayPeriod"), "de-AT locale has a 24-hour format");
+assert(resultVienna.includes(yearPartVienna), "de-AT locale string has a year part");
+assert(resultVienna.includes(monthPartVienna), "de-AT locale string has a month part");
+assert(resultVienna.includes(dayPartVienna), "de-AT locale string has a day part");
+assert(resultVienna.includes(hourPartVienna), "de-AT locale string has an hour part");
+assert(resultVienna.includes(minutePartVienna), "de-AT locale string has a minute part");
+assert(resultVienna.includes(secondPartVienna), "de-AT locale string has a second part");

test/intl402/Temporal/Instant/prototype/toLocaleString/option-timezonename-short.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.tolocalestring
+description: Instant.toLocaleString with option timeZoneName outputs a short name.
+features: [Temporal]
+locale: [en-US]
+---*/
+
+const instant = Temporal.Instant.from("1976-11-18T14:23:30Z");
+const str = instant.toLocaleString("en-US", {
+  timeZone: "America/New_York"
+});
+const strWithName = instant.toLocaleString("en-US", {
+  timeZone: "America/New_York",
+  timeZoneName: "short"
+});
+
+assert(str.length < strWithName.length,
+       'expected "' + str + '" to be shorter than "' + strWithName + '".');

test/intl402/Temporal/PlainDate/prototype/toLocaleString/basic.js

@@ -0,0 +1,69 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.tolocalestring
+description: Basic tests for Temporal.PlainDate.toLocaleString
+info: |
+    Temporal.PlainDate.prototype.toLocaleString ( [ locales [ , options ] ] )
+     ...
+    4. Return ? FormatDateTime(dateFormat, plainDate).
+    ...
+
+    FormatDateTime ( dateTimeFormat, x )
+    1. Let parts be ? PartitionDateTimePattern(dateTimeFormat, x).
+    2. Let result be the empty String.
+    3. For each Record { [[Type]], [[Value]] } part of parts, do
+        a. Set result to the string-concatenation of result and part.[[Value]].
+    4. Return result.
+
+    FormatDateTimeToParts ( dateTimeFormat, x )
+    1. Let parts be ? PartitionDateTimePattern(dateTimeFormat, x).
+    2. Let result be ! ArrayCreate(0).
+    3. Let n be 0.
+    4. For each Record { [[Type]], [[Value]] } part of parts, do
+           a. Let O be OrdinaryObjectCreate(%Object.prototype%).
+           b. Perform ! CreateDataPropertyOrThrow(O, "type", part.[[Type]]).
+           c. Perform ! CreateDataPropertyOrThrow(O, "value", part.[[Value]]).
+           d. Perform ! CreateDataPropertyOrThrow(result, ! ToString(𝔽(n)), O).
+           e. Increment n by 1.
+    5. Return result.
+features: [Temporal]
+locale: [en-US, de-AT]
+---*/
+
+function findPart(parts, expectedType) {
+  return parts.find(({ type }) => type === expectedType).value;
+}
+
+const date = Temporal.PlainDate.from("1976-11-18T15:23:30");
+
+const dtfNY = new Intl.DateTimeFormat("en-US", { timeZone: "America/New_York" });
+assert.sameValue(
+  date.toLocaleString("en-US", { timeZone: "America/New_York" }),
+  dtfNY.format(date)
+);
+
+const partsNY = dtfNY.formatToParts(date);
+const yearPartNY = findPart(partsNY, "year");
+const monthPartNY = findPart(partsNY, "month");
+const dayPartNY = findPart(partsNY, "day");
+const resultNY = date.toLocaleString("en-US", { timeZone: "America/New_York" });
+assert(resultNY.includes(yearPartNY), "en-US locale string has a year part");
+assert(resultNY.includes(monthPartNY), "en-US locale string has a month part");
+assert(resultNY.includes(dayPartNY), "en-US locale string has a day part");
+
+const dtfVienna = new Intl.DateTimeFormat("de-AT", { timeZone: "Europe/Vienna" });
+assert.sameValue(
+  date.toLocaleString("de-AT", { timeZone: "Europe/Vienna" }),
+  dtfVienna.format(date)
+);
+
+const partsVienna = dtfVienna.formatToParts(date);
+const yearPartVienna = findPart(partsVienna, "year");
+const monthPartVienna = findPart(partsVienna, "month");
+const dayPartVienna = findPart(partsVienna, "day");
+const resultVienna = date.toLocaleString("de-AT", { timeZone: "Europe/Vienna" });
+assert(resultVienna.includes(yearPartVienna), "de-AT locale string has a year part");
+assert(resultVienna.includes(monthPartVienna), "de-AT locale string has a month part");
+assert(resultVienna.includes(dayPartVienna), "de-AT locale string has a day part");

test/intl402/Temporal/PlainDateTime/prototype/toLocaleString/basic.js

@@ -0,0 +1,83 @@
+// 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.prototype.tolocalestring
+description: Basic tests for Temporal.PlainDateTime.toLocaleString
+info: |
+    Temporal.PlainDateTime.prototype.toLocaleString ( [ locales [ , options ] ] )
+     ...
+    4. Return ? FormatDateTime(dateFormat, plainDateTime).
+    ...
+
+    FormatDateTime ( dateTimeFormat, x )
+    1. Let parts be ? PartitionDateTimePattern(dateTimeFormat, x).
+    2. Let result be the empty String.
+    3. For each Record { [[Type]], [[Value]] } part of parts, do
+        a. Set result to the string-concatenation of result and part.[[Value]].
+    4. Return result.
+
+    FormatDateTimeToParts ( dateTimeFormat, x )
+    1. Let parts be ? PartitionDateTimePattern(dateTimeFormat, x).
+    2. Let result be ! ArrayCreate(0).
+    3. Let n be 0.
+    4. For each Record { [[Type]], [[Value]] } part of parts, do
+           a. Let O be OrdinaryObjectCreate(%Object.prototype%).
+           b. Perform ! CreateDataPropertyOrThrow(O, "type", part.[[Type]]).
+           c. Perform ! CreateDataPropertyOrThrow(O, "value", part.[[Value]]).
+           d. Perform ! CreateDataPropertyOrThrow(result, ! ToString(𝔽(n)), O).
+           e. Increment n by 1.
+    5. Return result.
+features: [Temporal]
+locale: [en-US, de-AT]
+---*/
+
+function findPart(parts, expectedType) {
+  return parts.find(({ type }) => type === expectedType).value;
+}
+
+const datetime = Temporal.PlainDateTime.from("1976-11-18T15:23:30");
+
+const dtfNY = new Intl.DateTimeFormat("en-US", { timeZone: "America/New_York" });
+assert.sameValue(
+  datetime.toLocaleString("en-US", { timeZone: "America/New_York" }),
+  dtfNY.format(datetime)
+);
+
+const partsNY = dtfNY.formatToParts(datetime);
+const yearPartNY = findPart(partsNY, "year");
+const monthPartNY = findPart(partsNY, "month");
+const dayPartNY = findPart(partsNY, "day");
+const hourPartNY = findPart(partsNY, "hour");
+const minutePartNY = findPart(partsNY, "minute");
+const secondPartNY = findPart(partsNY, "second");
+const resultNY = datetime.toLocaleString("en-US", { timeZone: "America/New_York" });
+assert(partsNY.some(part => part.type === "dayPeriod"), "en-US locale has a 12-hour format");
+assert(resultNY.includes(yearPartNY), "en-US locale string has a year part");
+assert(resultNY.includes(monthPartNY), "en-US locale string has a month part");
+assert(resultNY.includes(dayPartNY), "en-US locale string has a day part");
+assert(resultNY.includes(hourPartNY), "en-US locale string has an hour part");
+assert(resultNY.includes(minutePartNY), "en-US locale string has a minute part");
+assert(resultNY.includes(secondPartNY), "en-US locale string has a second part");
+
+const dtfVienna = new Intl.DateTimeFormat("de-AT", { timeZone: "Europe/Vienna" });
+assert.sameValue(
+  datetime.toLocaleString("de-AT", { timeZone: "Europe/Vienna" }),
+  dtfVienna.format(datetime)
+);
+
+const partsVienna = dtfVienna.formatToParts(datetime);
+const yearPartVienna = findPart(partsVienna, "year");
+const monthPartVienna = findPart(partsVienna, "month");
+const dayPartVienna = findPart(partsVienna, "day");
+const hourPartVienna = findPart(partsVienna, "hour");
+const minutePartVienna = findPart(partsVienna, "minute");
+const secondPartVienna = findPart(partsVienna, "second");
+const resultVienna = datetime.toLocaleString("de-AT", { timeZone: "Europe/Vienna" });
+assert(!partsVienna.some(part => part.type === "dayPeriod"), "de-AT locale has a 24-hour format");
+assert(resultVienna.includes(yearPartVienna), "de-AT locale string has a year part");
+assert(resultVienna.includes(monthPartVienna), "de-AT locale string has a month part");
+assert(resultVienna.includes(dayPartVienna), "de-AT locale string has a day part");
+assert(resultVienna.includes(hourPartVienna), "de-AT locale string has an hour part");
+assert(resultVienna.includes(minutePartVienna), "de-AT locale string has a minute part");
+assert(resultVienna.includes(secondPartVienna), "de-AT locale string has a second part");