tyler.durden/test262
1
0
Fork 0
mirror of https://github.com/tc39/test262.git synced 2025-04-08 19:35:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

Fix islamic-rgsa calendar test case

Browse Source
This commit is contained in:
André Bargull 2025-03-14 09:52:56 +01:00 committed by Ms2ger
parent e296fb39a6
commit d2a0a9bda6
1 changed files with 273 additions and 349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

622
test/staging/Intl402/Temporal/old/non-iso-calendars-islamic-rgsa.js
View File

@ -4,205 +4,156 @@
/*--- /*---
esid: sec-temporal-intl esid: sec-temporal-intl
description: Non-ISO Calendars description: Non-ISO Calendars
features: [Temporal, Array.prototype.includes] features: [Temporal]
locale: locale:
- en-US-u-ca-islamic-rgsa - en-US-u-ca-islamic-rgsa
---*/ ---*/
var hasOutdatedChineseIcuData = false; const calendar = "islamic-rgsa";
// verify that Intl.DateTimeFormat.formatToParts output matches snapshot data // verify that Intl.DateTimeFormat.formatToParts output matches snapshot data
function compareFormatToPartsSnapshot(isoString, expected) { function compareFormatToPartsSnapshot(isoString, expectedComponents) {
const date = new Date(isoString); const date = new Date(isoString);
Object.entries(expected).forEach(([calendar, expectedComponents]) => { const formatter = new Intl.DateTimeFormat(`en-US-u-ca-${calendar}`, { timeZone: "UTC" });
const formatter = new Intl.DateTimeFormat(`en-US-u-ca-${calendar}`, { timeZone: "UTC" }); const actualComponents = formatter.formatToParts(date);
const actualComponents = formatter.formatToParts(date); for (let [expectedType, expectedValue] of Object.entries(expectedComponents)) {
Object.entries(expectedComponents).forEach(([expectedType, expectedValue]) => { const part = actualComponents.find(({type}) => type === expectedType);
const part = actualComponents.find(({type}) => type === expectedType); const contextMessage = `${expectedType} component of ${isoString} formatted in ${calendar}`;
const contextMessage = `${expectedType} component of ${isoString} formatted in ${calendar}`; assert.notSameValue(part, undefined, contextMessage);
assert.notSameValue(part, undefined, contextMessage); assert.sameValue(part.value, `${expectedValue}`, contextMessage);
assert.sameValue(part.value, `${expectedValue}`, contextMessage); }
});
});
} }
compareFormatToPartsSnapshot("2000-01-01T00:00Z", { compareFormatToPartsSnapshot("2000-01-01T00:00Z", {
"islamic-rgsa": { year: 1420,
year: 1420, era: "AH",
era: "AH", month: 9,
month: 9, // day: 25,
day: 25,
},
}); });
compareFormatToPartsSnapshot("0001-01-01T00:00Z", { compareFormatToPartsSnapshot("0001-01-01T00:00Z", {
"islamic-rgsa": { year: -640,
year: -640, era: "AH",
era: "AH", month: 5,
month: 5, // day: 20,
day: 20,
},
}); });
var fromWithCases = { var fromWithCases = {
"islamic-rgsa": { year2000: {
year2000: { year: 1420,
year: 1420, month: 9,
month: 9, monthCode: "M09",
day: 25, day: [23, 25],
era: "ah"
},
year1: {
year: -640,
month: 5,
day: 20,
era: "ah"
}
}, },
}; year1: {
for (var [id, tests] of Object.entries(fromWithCases)) { year: -640,
var dates = { month: 5,
year2000: Temporal.PlainDate.from("2000-01-01"), monthCode: "M05",
year1: Temporal.PlainDate.from("0001-01-01") day: [20, 19],
};
for (var [name, date] of Object.entries(dates)) {
var values = tests[name];
var errorExpected = values === RangeError;
if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) {
if (errorExpected) {
assert.throws(RangeError, () => {
var inCal = date.withCalendar(id);
Temporal.PlainDate.from({
calendar: id,
year: inCal.year,
day: inCal.day,
monthCode: inCal.monthCode
});
});
}
var inCal = date.withCalendar(id);
assert.sameValue(`${ name } ${ id } day: ${ inCal.day }`, `${ name } ${ id } day: ${ values.day }`);
if (values.eraYear === undefined && values.era !== undefined)
values.eraYear = values.year;
assert.sameValue(`${ name } ${ id } eraYear: ${ inCal.eraYear }`, `${ name } ${ id } eraYear: ${ values.eraYear }`);
assert.sameValue(`${ name } ${ id } era: ${ inCal.era }`, `${ name } ${ id } era: ${ values.era }`);
assert.sameValue(`${ name } ${ id } year: ${ inCal.year }`, `${ name } ${ id } year: ${ values.year }`);
assert.sameValue(`${ name } ${ id } month: ${ inCal.month }`, `${ name } ${ id } month: ${ values.month }`);
if (values.monthCode === undefined)
values.monthCode = `M${ values.month.toString().padStart(2, "0") }`;
assert.sameValue(`${ name } ${ id } monthCode: ${ inCal.monthCode }`, `${ name } ${ id } monthCode: ${ values.monthCode }`);
if (values.era) {
var dateRoundtrip1 = Temporal.PlainDate.from({
calendar: id,
eraYear: values.eraYear,
era: values.era,
day: values.day,
monthCode: values.monthCode
});
assert.sameValue(dateRoundtrip1.toString(), inCal.toString());
assert.throws(RangeError, () => Temporal.PlainDate.from({
calendar: id,
eraYear: values.eraYear,
era: values.era,
day: values.day,
monthCode: values.monthCode,
year: values.year + 1
}));
}
var dateRoundtrip2 = Temporal.PlainDate.from({
calendar: id,
year: values.year,
day: values.day,
monthCode: values.monthCode
});
assert.sameValue(dateRoundtrip2.toString(), inCal.toString());
var dateRoundtrip3 = Temporal.PlainDate.from({
calendar: id,
year: values.year,
day: values.day,
month: values.month
});
assert.sameValue(dateRoundtrip3.toString(), inCal.toString());
var dateRoundtrip4 = Temporal.PlainDate.from({
calendar: id,
year: values.year,
day: values.day,
monthCode: values.monthCode
});
assert.sameValue(dateRoundtrip4.toString(), inCal.toString());
assert.throws(RangeError, () => Temporal.PlainDate.from({
calendar: id,
day: values.day,
month: values.month === 1 ? 2 : values.month - 1,
monthCode: values.monthCode,
year: values.year
}));
};
if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) {
var inCal = date.withCalendar(id);
if (errorExpected) {
assert.throws(RangeError, () => inCal.with({ day: 1 }).year);
}
var afterWithDay = inCal.with({ day: 1 });
var t = "(after setting day)";
assert.sameValue(`${ t } year: ${ afterWithDay.year }`, `${ t } year: ${ inCal.year }`);
assert.sameValue(`${ t } month: ${ afterWithDay.month }`, `${ t } month: ${ inCal.month }`);
assert.sameValue(`${ t } day: ${ afterWithDay.day }`, `${ t } day: 1`);
var afterWithMonth = afterWithDay.with({ month: 1 });
t = "(after setting month)";
assert.sameValue(`${ t } year: ${ afterWithMonth.year }`, `${ t } year: ${ inCal.year }`);
assert.sameValue(`${ t } month: ${ afterWithMonth.month }`, `${ t } month: 1`);
assert.sameValue(`${ t } day: ${ afterWithMonth.day }`, `${ t } day: 1`);
var afterWithYear = afterWithMonth.with({ year: 2220 });
t = "(after setting year)";
assert.sameValue(`${ t } year: ${ afterWithYear.year }`, `${ t } year: 2220`);
assert.sameValue(`${ t } month: ${ afterWithYear.month }`, `${ t } month: 1`);
assert.sameValue(`${ t } day: ${ afterWithYear.day }`, `${ t } day: 1`);
};
} }
};
var dates = {
year2000: Temporal.PlainDate.from("2000-01-01"),
year1: Temporal.PlainDate.from("0001-01-01")
};
for (var [name, result] of Object.entries(fromWithCases)) {
var date = dates[name];
var inCal = date.withCalendar(calendar);
assert.sameValue(inCal.era, result.era, `${name}: era`);
assert.sameValue(inCal.eraYear, result.eraYear, `${name}: eraYear`);
assert.sameValue(inCal.year, result.year, `${name}: year`);
assert.sameValue(inCal.month, result.month, `${name}: month`);
assert.sameValue(inCal.monthCode, result.monthCode, `${name}: monthCode`);
assert(result.day.includes(inCal.day), `${name}: day`);
var dateRoundtrip2 = Temporal.PlainDate.from({
calendar,
year: result.year,
day: inCal.day,
monthCode: result.monthCode
});
assert.sameValue(dateRoundtrip2.toString(), inCal.toString());
var dateRoundtrip3 = Temporal.PlainDate.from({
calendar,
year: result.year,
day: inCal.day,
month: result.month
});
assert.sameValue(dateRoundtrip3.toString(), inCal.toString());
var dateRoundtrip4 = Temporal.PlainDate.from({
calendar,
year: result.year,
day: inCal.day,
monthCode: result.monthCode
});
assert.sameValue(dateRoundtrip4.toString(), inCal.toString());
assert.throws(RangeError, () => Temporal.PlainDate.from({
calendar,
day: inCal.day,
month: result.month === 1 ? 2 : result.month - 1,
monthCode: result.monthCode,
year: result.year
}));
var afterWithDay = inCal.with({ day: 1 });
assert.sameValue(afterWithDay.year, inCal.year, `${name} (after setting day)`);
assert.sameValue(afterWithDay.month, inCal.month, `${name} (after setting day)`);
assert.sameValue(afterWithDay.day, 1, `${name} (after setting day)`);
var afterWithMonth = afterWithDay.with({ month: 1 });
assert.sameValue(afterWithMonth.year, inCal.year, `${name} (after setting month)`);
assert.sameValue(afterWithMonth.month, 1, `${name} (after setting month)`);
assert.sameValue(afterWithMonth.day, 1, `${name} (after setting month)`);
var afterWithYear = afterWithMonth.with({ year: 2220 });
assert.sameValue(afterWithYear.year, 2220, `${name} (after setting year)`);
assert.sameValue(afterWithYear.month, 1, `${name} (after setting year)`);
assert.sameValue(afterWithYear.day, 1, `${name} (after setting year)`);
} }
var addDaysWeeksCases = {
"islamic-rgsa": { var durationCases = {
year: 2000,
month: 10,
day: 15,
monthCode: "M10",
eraYear: 2000,
era: "ah"
},
};
const addMonthsCases = {
'islamic-rgsa': { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'ah' },
};
var i = 0;
const addYearsMonthsDaysCases = Object.entries(addMonthsCases).reduce((obj, entry) => {
obj[entry[0]] = entry[1] === RangeError ? RangeError : { ...entry[1], day: 18 };
return obj;
}, {});
var tests = {
days: { days: {
duration: { days: 280 }, duration: { days: 280 },
results: addDaysWeeksCases, result: {
year: 1426,
month: 10,
monthCode: "M10",
day: [15, 14],
},
startDate: { startDate: {
year: 2000, year: 1426,
month: 1, month: 1,
day: 1 day: 1
} }
}, },
weeks: { weeks: {
duration: { weeks: 40 }, duration: { weeks: 40 },
results: addDaysWeeksCases, result: {
year: 1426,
month: 10,
monthCode: "M10",
day: [15, 14],
},
startDate: { startDate: {
year: 2000, year: 1426,
month: 1, month: 1,
day: 1 day: 1
} }
}, },
months: { months: {
duration: { months: 6 }, duration: { months: 6 },
results: addMonthsCases, result: {
year: 1427,
month: 6,
monthCode: "M06",
day: [1, 2],
},
startDate: { startDate: {
year: 2000, year: 1426,
month: 12, month: 12,
day: 1 day: 1
} }
@ -213,228 +164,201 @@ var tests = {
months: 6, months: 6,
days: 17 days: 17
}, },
results: addYearsMonthsDaysCases, result: {
year: 1427,
month: 6,
monthCode: "M06",
day: [18, 19],
},
startDate: { startDate: {
year: 1997, year: 1423,
monthCode: "M12", monthCode: "M12",
day: 1 day: 1
} }
} }
}; };
for (var id of Object.keys(addMonthsCases)) { for (var [unit, {duration, result, startDate}] of Object.entries(durationCases)) {
for (var [unit, {duration, results, startDate}] of Object.entries(tests)) { duration = Temporal.Duration.from(duration);
var values = results[id];
duration = Temporal.Duration.from(duration); var start = Temporal.PlainDate.from({
if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) { ...startDate,
if (values === RangeError) { calendar
assert.throws(RangeError, () => Temporal.PlainDate.from({ });
...startDate,
calendar: id var end = start.add(duration);
})); assert.sameValue(end.era, result.era, `${unit}`);
} assert.sameValue(end.eraYear, result.eraYear, `${unit}`);
var start = Temporal.PlainDate.from({ assert.sameValue(end.year, result.year, `${unit}`);
...startDate, assert.sameValue(end.month, result.month, `${unit}`);
calendar: id assert.sameValue(end.monthCode, result.monthCode, `${unit}`);
}); assert(result.day.includes(end.day), `${unit}`);
var end = start.add(duration);
assert.sameValue(`add ${ unit } ${ id } day: ${ end.day }`, `add ${ unit } ${ id } day: ${ values.day }`); var calculatedStart = end.subtract(duration);
assert.sameValue(`add ${ unit } ${ id } eraYear: ${ end.eraYear }`, `add ${ unit } ${ id } eraYear: ${ values.eraYear }`); var expectedCalculatedStart = start;
assert.sameValue(`add ${ unit } ${ id } era: ${ end.era }`, `add ${ unit } ${ id } era: ${ values.era }`); assert.sameValue(calculatedStart.toString(), expectedCalculatedStart.toString(), `${unit}`);
assert.sameValue(`add ${ unit } ${ id } year: ${ end.year }`, `add ${ unit } ${ id } year: ${ values.year }`);
assert.sameValue(`add ${ unit } ${ id } month: ${ end.month }`, `add ${ unit } ${ id } month: ${ values.month }`); var diff = start.until(end, { largestUnit: unit });
assert.sameValue(`add ${ unit } ${ id } monthCode: ${ end.monthCode }`, `add ${ unit } ${ id } monthCode: ${ values.monthCode }`); assert.sameValue(diff.toString(), duration.toString(), `${unit}`);
var calculatedStart = end.subtract(duration);
var isLunisolar = [ if (unit === "months") {
"chinese", var startYesterday = start.subtract({ days: 1 });
"dangi", var endYesterday = startYesterday.add(duration);
"hebrew" assert.sameValue(endYesterday.day, Math.min(startYesterday.day, endYesterday.daysInMonth), `${unit}`);
].includes(id);
var expectedCalculatedStart = isLunisolar && duration.years !== 0 && !end.monthCode.endsWith("L") ? start.subtract({ months: 1 }) : start; var endYesterdayNextDay = endYesterday.add({ days: 1 });
assert.sameValue(`start ${ calculatedStart.toString() }`, `start ${ expectedCalculatedStart.toString() }`); while (endYesterdayNextDay.day !== 1) {
var diff = start.until(end, { largestUnit: unit }); endYesterdayNextDay = endYesterdayNextDay.add({ days: 1 });
assert.sameValue(`diff ${ unit } ${ id }: ${ diff }`, `diff ${ unit } ${ id }: ${ duration }`); }
if (unit === "months") { assert.sameValue(endYesterdayNextDay.era, result.era, `${unit}`);
var startYesterday = start.subtract({ days: 1 }); assert.sameValue(endYesterdayNextDay.eraYear, result.eraYear, `${unit}`);
var endYesterday = startYesterday.add(duration); assert.sameValue(endYesterdayNextDay.year, result.year, `${unit}`);
assert.sameValue(`add from end-of-month ${ unit } ${ id } day (initial): ${ endYesterday.day }`, `add from end-of-month ${ unit } ${ id } day (initial): ${ Math.min(startYesterday.day, endYesterday.daysInMonth) }`); assert.sameValue(endYesterdayNextDay.month, result.month, `${unit}`);
var endYesterdayNextDay = endYesterday.add({ days: 1 }); assert.sameValue(endYesterdayNextDay.monthCode, result.monthCode, `${unit}`);
while (endYesterdayNextDay.day !== 1) { assert(result.day.includes(endYesterdayNextDay.day), `${unit}`);
endYesterdayNextDay = endYesterdayNextDay.add({ days: 1 });
} var endReverse = endYesterdayNextDay.subtract({ days: 1 });
assert.sameValue(`add from end-of-month ${ unit } ${ id } day: ${ endYesterdayNextDay.day }`, `add from end-of-month ${ unit } ${ id } day: ${ values.day }`); var startReverse = endReverse.subtract(duration);
assert.sameValue(`add from end-of-month ${ unit } ${ id } eraYear: ${ endYesterdayNextDay.eraYear }`, `add from end-of-month ${ unit } ${ id } eraYear: ${ values.eraYear }`); assert.sameValue(startReverse.day, Math.min(endReverse.day, startReverse.daysInMonth));
assert.sameValue(`add from end-of-month ${ unit } ${ id } era: ${ endYesterdayNextDay.era }`, `add from end-of-month ${ unit } ${ id } era: ${ values.era }`);
assert.sameValue(`add from end-of-month ${ unit } ${ id } year: ${ endYesterdayNextDay.year }`, `add from end-of-month ${ unit } ${ id } year: ${ values.year }`); var startReverseNextDay = startReverse.add({ days: 1 });
assert.sameValue(`add from end-of-month ${ unit } ${ id } month: ${ endYesterdayNextDay.month }`, `add from end-of-month ${ unit } ${ id } month: ${ values.month }`); while (startReverseNextDay.day !== 1) {
assert.sameValue(`add from end-of-month ${ unit } ${ id } monthCode: ${ endYesterdayNextDay.monthCode }`, `add from end-of-month ${ unit } ${ id } monthCode: ${ values.monthCode }`); startReverseNextDay = startReverseNextDay.add({ days: 1 });
var endReverse = endYesterdayNextDay.subtract({ days: 1 }); }
var startReverse = endReverse.subtract(duration); assert.sameValue(startReverseNextDay.era, start.era, `${unit}`);
assert.sameValue(`subtract from end-of-month ${ unit } ${ id } day (initial): ${ startReverse.day }`, `subtract from end-of-month ${ unit } ${ id } day (initial): ${ Math.min(endReverse.day, startReverse.daysInMonth) }`); assert.sameValue(startReverseNextDay.eraYear, start.eraYear, `${unit}`);
var startReverseNextDay = startReverse.add({ days: 1 }); assert.sameValue(startReverseNextDay.year, start.year, `${unit}`);
while (startReverseNextDay.day !== 1) { assert.sameValue(startReverseNextDay.month, start.month, `${unit}`);
startReverseNextDay = startReverseNextDay.add({ days: 1 }); assert.sameValue(startReverseNextDay.monthCode, start.monthCode, `${unit}`);
} assert.sameValue(startReverseNextDay.day, start.day, `${unit}`);
assert.sameValue(`subtract from end-of-month ${ unit } ${ id } day: ${ startReverseNextDay.day }`, `subtract from end-of-month ${ unit } ${ id } day: ${ start.day }`);
assert.sameValue(`subtract from end-of-month ${ unit } ${ id } eraYear: ${ startReverseNextDay.eraYear }`, `subtract from end-of-month ${ unit } ${ id } eraYear: ${ start.eraYear }`);
assert.sameValue(`subtract from end-of-month ${ unit } ${ id } era: ${ startReverseNextDay.era }`, `subtract from end-of-month ${ unit } ${ id } era: ${ start.era }`);
assert.sameValue(`subtract from end-of-month ${ unit } ${ id } year: ${ startReverseNextDay.year }`, `subtract from end-of-month ${ unit } ${ id } year: ${ start.year }`);
assert.sameValue(`subtract from end-of-month ${ unit } ${ id } month: ${ startReverseNextDay.month }`, `subtract from end-of-month ${ unit } ${ id } month: ${ start.month }`);
assert.sameValue(`subtract from end-of-month ${ unit } ${ id } monthCode: ${ startReverseNextDay.monthCode }`, `subtract from end-of-month ${ unit } ${ id } monthCode: ${ start.monthCode }`);
}
};
} }
} }
var daysInMonthCases = {
"islamic-rgsa": { var daysInMonthCases = [
year: 2001, {
year: 1424,
leap: false, leap: false,
days: [ days: [[
29,
30,
30,
29,
30,
29, 29,
30, 30,
29, 29,
29, 29,
30, 30,
29, 29,
30, 30
], [
30, 30,
29, 29,
30, 30,
29,
30,
29,
30,
29,
30,
29,
30, 30,
29 29
] ]]
}, },
}; ];
for (var id of Object.keys(daysInMonthCases)) { for (var {year, leap, days} of daysInMonthCases) {
var {year, leap, days} = daysInMonthCases[id]; var date = Temporal.PlainDate.from({
var date = hasOutdatedChineseIcuData && (id === "chinese" || id === "dangi") ? undefined : Temporal.PlainDate.from({
year, year,
month: 1, month: 1,
day: 1, day: 1,
calendar: id calendar
}); });
if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) { assert.sameValue(date.inLeapYear, leap);
if (typeof leap === "boolean") {
assert.sameValue(date.inLeapYear, leap); var {monthsInYear} = date;
} else { assert.sameValue(monthsInYear, days[0].length);
assert.sameValue(date.inLeapYear, true);
var leapMonth = date.with({ monthCode: leap }); for (var i = monthsInYear, monthStart = undefined, daysIndex = undefined; i >= 1; i--) {
assert.sameValue(leapMonth.monthCode, leap); monthStart = monthStart ? monthStart.add({ months: -1 }) : date.add({ months: monthsInYear - 1 });
var {month, monthCode, daysInMonth} = monthStart;
assert.sameValue(month, i);
if (daysIndex === undefined) {
daysIndex = days.findIndex(e => e[i - 1] === daysInMonth);
} }
}; assert.sameValue(daysInMonth, days[daysIndex][i - 1]);
if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) {
var {monthsInYear} = date; assert.sameValue(monthCode.endsWith("L"), false);
assert.sameValue(monthsInYear, days.length); assert.throws(RangeError, () => monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` }));
for (var i = monthsInYear, leapMonthIndex = undefined, monthStart = undefined; i >= 1; i--) { assert.throws(RangeError, () => monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` }, { overflow: "reject" }));
monthStart = monthStart ? monthStart.add({ months: -1 }) : date.add({ months: monthsInYear - 1 });
var {month, monthCode, daysInMonth} = monthStart; var oneDayPastMonthEnd = monthStart.with({ day: daysInMonth + 1 });
assert.sameValue(`${ id } month ${ i } (code ${ monthCode }) days: ${ daysInMonth }`, `${ id } month ${ i } (code ${ monthCode }) days: ${ days[i - 1] }`); assert.sameValue(oneDayPastMonthEnd.day, daysInMonth);
if (monthCode.endsWith("L")) { assert.throws(RangeError, () => monthStart.with({ day: daysInMonth + 1 }, { overflow: "reject" }));
assert.sameValue(date.with({ monthCode }).monthCode, monthCode); }
leapMonthIndex = i;
} else {
if (leapMonthIndex && i === leapMonthIndex - 1) {
var inLeapMonth = monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` });
assert.sameValue(inLeapMonth.monthCode, `${ monthCode }L`);
} else {
assert.throws(RangeError, () => monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` }, { overflow: "reject" }));
if ([
"chinese",
"dangi"
].includes(id)) {
if (i === 1 || i === 12 || i === 13) {
assert.throws(RangeError, () => monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` }));
} else {
var fakeL = monthStart.with({
monthCode: `M${ month.toString().padStart(2, "0") }L`,
day: 5
});
assert.sameValue(`fake leap month ${ fakeL.monthCode }`, `fake leap month M${ month.toString().padStart(2, "0") }`);
assert.sameValue(fakeL.day, fakeL.daysInMonth);
}
}
}
if (![
"chinese",
"dangi",
"hebrew"
].includes(id)) {
assert.throws(RangeError, () => monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` }));
}
}
assert.throws(RangeError, () => monthStart.with({ day: daysInMonth + 1 }, { overflow: "reject" }));
var oneDayPastMonthEnd = monthStart.with({ day: daysInMonth + 1 });
assert.sameValue(oneDayPastMonthEnd.day, daysInMonth);
}
};
} }
var monthDayCases = [ var monthDayCases = [
{ {
calendar: "islamic-rgsa", year: 1424,
isoReferenceYear: 1970, month: 3,
year: 2001, monthCode: "M03",
month: 1,
day: 30 day: 30
}, },
]; ];
var i = 0; for (var {monthCode, month, day, year} of monthDayCases) {
for (var test of monthDayCases) { var md = Temporal.PlainMonthDay.from({
var id = test.calendar; year,
if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) { month,
if (test.monthCode === undefined) day,
test.monthCode = `M${ test.month.toString().padStart(2, "0") }`; calendar
var {calendar, monthCode, month, day, year, isoReferenceYear} = test; });
var md = Temporal.PlainMonthDay.from({ var isoString = md.toString();
year,
month, var mdFromIso = Temporal.PlainMonthDay.from(isoString);
day, assert.sameValue(mdFromIso.toString(), isoString);
assert.sameValue(md.monthCode, monthCode);
assert.sameValue(md.day, day);
var md2 = Temporal.PlainMonthDay.from({
monthCode,
day,
calendar
});
assert.sameValue(md2.monthCode, monthCode);
assert.sameValue(md2.day, day);
assert.sameValue(md.equals(md2), true);
assert.throws(RangeError, () => {
Temporal.PlainMonthDay.from({
monthCode: "M15",
day: 1,
calendar
}, { overflow: "reject" });
});
assert.throws(RangeError, () => {
Temporal.PlainMonthDay.from({
monthCode: "M15",
day: 1,
calendar calendar
}); });
var isoString = md.toString(); });
var mdFromIso = Temporal.PlainMonthDay.from(isoString);
assert.sameValue(mdFromIso, md); assert.throws(RangeError, () => {
var isoFields = md.getISOFields(); Temporal.PlainMonthDay.from({
assert.sameValue(md.monthCode, monthCode);
assert.sameValue(md.day, day);
assert.sameValue(isoFields.isoYear, isoReferenceYear);
var md2 = Temporal.PlainMonthDay.from({
monthCode,
day,
calendar
});
var isoFields2 = md2.getISOFields();
assert.sameValue(md2.monthCode, monthCode);
assert.sameValue(md2.day, day);
assert.sameValue(isoFields2.isoYear, isoReferenceYear);
assert.sameValue(md.equals(md2), true);
assert.throws(RangeError, () => {
Temporal.PlainMonthDay.from({
monthCode: "M15",
day: 1,
calendar
}, { overflow: "reject" });
});
assert.throws(RangeError, () => {
Temporal.PlainMonthDay.from({
monthCode: "M15",
day: 1,
calendar
});
});
assert.throws(RangeError, () => {
Temporal.PlainMonthDay.from({
year,
month: 15,
day: 1,
calendar
}, { overflow: "reject" });
});
var constrained = Temporal.PlainMonthDay.from({
year, year,
month: 15, month: 15,
day: 1, day: 1,
calendar calendar
}); }, { overflow: "reject" });
var {monthCode: monthCodeConstrained} = constrained; });
assert(monthCodeConstrained === "M12" || monthCodeConstrained === "M13");
}; var constrained = Temporal.PlainMonthDay.from({
year,
month: 15,
day: 1,
calendar
});
assert.sameValue(constrained.monthCode, "M12");
} }