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

Fix dangi calendar test case

Browse Source
This commit is contained in:
André Bargull 2025-03-14 09:52:57 +01:00 committed by Ms2ger
parent 367b207786
commit 7f61f1d73e
1 changed files with 278 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

618
test/staging/Intl402/Temporal/old/non-iso-calendars-dangi.js
View File

@ -4,7 +4,7 @@
/*--- /*---
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-dangi - en-US-u-ca-dangi
---*/ ---*/
@ -18,195 +18,154 @@ var testChineseData = new Date("2001-02-01T00:00Z").toLocaleString("en-US-u-ca-c
}); });
var hasOutdatedChineseIcuData = !testChineseData.endsWith("2001"); var hasOutdatedChineseIcuData = !testChineseData.endsWith("2001");
const calendar = "dangi";
const dangiYearOffset = new Temporal.PlainDate(1, 1, 1, calendar).year;
// 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", {
dangi: { relatedYear: 1999,
relatedYear: 1999, month: 11,
month: 11, day: 25,
day: 25,
},
}); });
compareFormatToPartsSnapshot("0001-01-01T00:00Z", { compareFormatToPartsSnapshot("0001-01-01T00:00Z", {
dangi: { relatedYear: 0,
relatedYear: 0, month: 11,
month: 11, day: 21,
day: 21,
},
}); });
var fromWithCases = { var fromWithCases = {
dangi: { year2000: {
year2000: { year: 1999 + dangiYearOffset,
year: 1999, month: 11,
month: 11, monthCode: "M11",
day: 25 day: 25
},
year1: {
year: 0,
month: 12,
monthCode: "M11",
day: 21
}
}, },
}; year1: {
for (var [id, tests] of Object.entries(fromWithCases)) { year: 0 + dangiYearOffset,
var dates = { month: 12,
year2000: Temporal.PlainDate.from("2000-01-01"), monthCode: "M11",
year1: Temporal.PlainDate.from("0001-01-01") day: 21
};
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)) {
if (hasOutdatedChineseIcuData) {
continue;
}
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.sameValue(inCal.day, result.day, `${name}: day`);
var dateRoundtrip2 = Temporal.PlainDate.from({
calendar,
year: result.year,
day: result.day,
monthCode: result.monthCode
});
assert.sameValue(dateRoundtrip2.toString(), inCal.toString());
var dateRoundtrip3 = Temporal.PlainDate.from({
calendar,
year: result.year,
day: result.day,
month: result.month
});
assert.sameValue(dateRoundtrip3.toString(), inCal.toString());
var dateRoundtrip4 = Temporal.PlainDate.from({
calendar,
year: result.year,
day: result.day,
monthCode: result.monthCode
});
assert.sameValue(dateRoundtrip4.toString(), inCal.toString());
assert.throws(RangeError, () => Temporal.PlainDate.from({
calendar,
day: result.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 = {
dangi: { var durationCases = {
year: 2000,
month: 10,
day: 16,
monthCode: "M10",
eraYear: undefined,
era: undefined
},
};
const addMonthsCases = {
dangi: { year: 2001, month: 6, day: 1, monthCode: 'M05', eraYear: undefined, era: undefined },
};
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: 2000 + dangiYearOffset,
month: 10,
monthCode: "M10",
day: 16,
},
startDate: { startDate: {
year: 2000, year: 2000 + dangiYearOffset,
month: 1, month: 1,
day: 1 day: 1
} }
}, },
weeks: { weeks: {
duration: { weeks: 40 }, duration: { weeks: 40 },
results: addDaysWeeksCases, result: {
year: 2000 + dangiYearOffset,
month: 10,
monthCode: "M10",
day: 16,
},
startDate: { startDate: {
year: 2000, year: 2000 + dangiYearOffset,
month: 1, month: 1,
day: 1 day: 1
} }
}, },
months: { months: {
duration: { months: 6 }, duration: { months: 6 },
results: addMonthsCases, result: {
year: 2001 + dangiYearOffset,
month: 6,
monthCode: "M05",
day: 1,
},
startDate: { startDate: {
year: 2000, year: 2000 + dangiYearOffset,
month: 12, month: 12,
day: 1 day: 1
} }
@ -217,80 +176,81 @@ var tests = {
months: 6, months: 6,
days: 17 days: 17
}, },
results: addYearsMonthsDaysCases, result: {
year: 2001 + dangiYearOffset,
month: 6,
monthCode: "M05",
day: 18,
},
startDate: { startDate: {
year: 1997, year: 1997 + dangiYearOffset,
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)) { if (hasOutdatedChineseIcuData) {
var values = results[id]; continue;
duration = Temporal.Duration.from(duration); }
if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) { duration = Temporal.Duration.from(duration);
if (values === RangeError) {
assert.throws(RangeError, () => Temporal.PlainDate.from({ var start = Temporal.PlainDate.from({
...startDate, ...startDate,
calendar: id calendar
})); });
}
var start = Temporal.PlainDate.from({ var end = start.add(duration);
...startDate, assert.sameValue(end.era, result.era, `${unit}`);
calendar: id assert.sameValue(end.eraYear, result.eraYear, `${unit}`);
}); assert.sameValue(end.year, result.year, `${unit}`);
var end = start.add(duration); assert.sameValue(end.month, result.month, `${unit}`);
assert.sameValue(`add ${ unit } ${ id } day: ${ end.day }`, `add ${ unit } ${ id } day: ${ values.day }`); assert.sameValue(end.monthCode, result.monthCode, `${unit}`);
assert.sameValue(`add ${ unit } ${ id } eraYear: ${ end.eraYear }`, `add ${ unit } ${ id } eraYear: ${ values.eraYear }`); assert.sameValue(end.day, result.day, `${unit}`);
assert.sameValue(`add ${ unit } ${ id } era: ${ end.era }`, `add ${ unit } ${ id } era: ${ values.era }`);
assert.sameValue(`add ${ unit } ${ id } year: ${ end.year }`, `add ${ unit } ${ id } year: ${ values.year }`); var calculatedStart = end.subtract(duration);
assert.sameValue(`add ${ unit } ${ id } month: ${ end.month }`, `add ${ unit } ${ id } month: ${ values.month }`); var expectedCalculatedStart = duration.years !== 0 && !end.monthCode.endsWith("L") ? start.subtract({ months: 1 }) : start;
assert.sameValue(`add ${ unit } ${ id } monthCode: ${ end.monthCode }`, `add ${ unit } ${ id } monthCode: ${ values.monthCode }`); assert.sameValue(calculatedStart.toString(), expectedCalculatedStart.toString(), `${unit}`);
var calculatedStart = end.subtract(duration);
var isLunisolar = [ var diff = start.until(end, { largestUnit: unit });
"chinese", assert.sameValue(diff.toString(), duration.toString(), `${unit}`);
"dangi",
"hebrew" if (unit === "months") {
].includes(id); var startYesterday = start.subtract({ days: 1 });
var expectedCalculatedStart = isLunisolar && duration.years !== 0 && !end.monthCode.endsWith("L") ? start.subtract({ months: 1 }) : start; var endYesterday = startYesterday.add(duration);
assert.sameValue(`start ${ calculatedStart.toString() }`, `start ${ expectedCalculatedStart.toString() }`); assert.sameValue(endYesterday.day, Math.min(startYesterday.day, endYesterday.daysInMonth), `${unit}`);
var diff = start.until(end, { largestUnit: unit });
assert.sameValue(`diff ${ unit } ${ id }: ${ diff }`, `diff ${ unit } ${ id }: ${ duration }`); var endYesterdayNextDay = endYesterday.add({ days: 1 });
if (unit === "months") { while (endYesterdayNextDay.day !== 1) {
var startYesterday = start.subtract({ days: 1 }); endYesterdayNextDay = endYesterdayNextDay.add({ days: 1 });
var endYesterday = startYesterday.add(duration); }
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.era, result.era, `${unit}`);
var endYesterdayNextDay = endYesterday.add({ days: 1 }); assert.sameValue(endYesterdayNextDay.eraYear, result.eraYear, `${unit}`);
while (endYesterdayNextDay.day !== 1) { assert.sameValue(endYesterdayNextDay.year, result.year, `${unit}`);
endYesterdayNextDay = endYesterdayNextDay.add({ days: 1 }); assert.sameValue(endYesterdayNextDay.month, result.month, `${unit}`);
} assert.sameValue(endYesterdayNextDay.monthCode, result.monthCode, `${unit}`);
assert.sameValue(`add from end-of-month ${ unit } ${ id } day: ${ endYesterdayNextDay.day }`, `add from end-of-month ${ unit } ${ id } day: ${ values.day }`); assert.sameValue(endYesterdayNextDay.day, result.day, `${unit}`);
assert.sameValue(`add from end-of-month ${ unit } ${ id } eraYear: ${ endYesterdayNextDay.eraYear }`, `add from end-of-month ${ unit } ${ id } eraYear: ${ values.eraYear }`);
assert.sameValue(`add from end-of-month ${ unit } ${ id } era: ${ endYesterdayNextDay.era }`, `add from end-of-month ${ unit } ${ id } era: ${ values.era }`); var endReverse = endYesterdayNextDay.subtract({ days: 1 });
assert.sameValue(`add from end-of-month ${ unit } ${ id } year: ${ endYesterdayNextDay.year }`, `add from end-of-month ${ unit } ${ id } year: ${ values.year }`); var startReverse = endReverse.subtract(duration);
assert.sameValue(`add from end-of-month ${ unit } ${ id } month: ${ endYesterdayNextDay.month }`, `add from end-of-month ${ unit } ${ id } month: ${ values.month }`); assert.sameValue(startReverse.day, Math.min(endReverse.day, startReverse.daysInMonth));
assert.sameValue(`add from end-of-month ${ unit } ${ id } monthCode: ${ endYesterdayNextDay.monthCode }`, `add from end-of-month ${ unit } ${ id } monthCode: ${ values.monthCode }`);
var endReverse = endYesterdayNextDay.subtract({ days: 1 }); var startReverseNextDay = startReverse.add({ days: 1 });
var startReverse = endReverse.subtract(duration); while (startReverseNextDay.day !== 1) {
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) }`); startReverseNextDay = startReverseNextDay.add({ days: 1 });
var startReverseNextDay = startReverse.add({ days: 1 }); }
while (startReverseNextDay.day !== 1) { assert.sameValue(startReverseNextDay.era, start.era, `${unit}`);
startReverseNextDay = startReverseNextDay.add({ days: 1 }); assert.sameValue(startReverseNextDay.eraYear, start.eraYear, `${unit}`);
} assert.sameValue(startReverseNextDay.year, start.year, `${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(startReverseNextDay.month, start.month, `${unit}`);
assert.sameValue(`subtract from end-of-month ${ unit } ${ id } eraYear: ${ startReverseNextDay.eraYear }`, `subtract from end-of-month ${ unit } ${ id } eraYear: ${ start.eraYear }`); assert.sameValue(startReverseNextDay.monthCode, start.monthCode, `${unit}`);
assert.sameValue(`subtract from end-of-month ${ unit } ${ id } era: ${ startReverseNextDay.era }`, `subtract from end-of-month ${ unit } ${ id } era: ${ start.era }`); assert.sameValue(startReverseNextDay.day, start.day, `${unit}`);
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 = {
dangi: { var daysInMonthCases = [
year: 2001, {
year: 2001 + dangiYearOffset,
leap: "M04L", leap: "M04L",
days: [ days: [
30, 30,
@ -308,146 +268,124 @@ var daysInMonthCases = {
30 30
] ]
}, },
}; ];
for (var id of Object.keys(daysInMonthCases)) { for (var {year, leap, days} of daysInMonthCases) {
var {year, leap, days} = daysInMonthCases[id]; if (hasOutdatedChineseIcuData) {
var date = hasOutdatedChineseIcuData && (id === "chinese" || id === "dangi") ? undefined : Temporal.PlainDate.from({ continue;
}
var date = 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, true);
if (typeof leap === "boolean") {
assert.sameValue(date.inLeapYear, leap); var leapMonth = date.with({ monthCode: leap });
assert.sameValue(leapMonth.monthCode, leap);
var {monthsInYear} = date;
assert.sameValue(monthsInYear, days.length);
for (var i = monthsInYear, leapMonthIndex = undefined, monthStart = undefined; i >= 1; i--) {
monthStart = monthStart ? monthStart.add({ months: -1 }) : date.add({ months: monthsInYear - 1 });
var {month, monthCode, daysInMonth} = monthStart;
assert.sameValue(month, i);
assert.sameValue(daysInMonth, days[i - 1]);
if (monthCode.endsWith("L")) {
assert.sameValue(date.with({ monthCode }).monthCode, leap);
leapMonthIndex = i;
} else { } else {
assert.sameValue(date.inLeapYear, true); if (leapMonthIndex !== undefined && i === leapMonthIndex - 1) {
var leapMonth = date.with({ monthCode: leap }); var inLeapMonth = monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` });
assert.sameValue(leapMonth.monthCode, leap); assert.sameValue(inLeapMonth.monthCode, `${ monthCode }L`);
}
};
if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) {
var {monthsInYear} = date;
assert.sameValue(monthsInYear, days.length);
for (var i = monthsInYear, leapMonthIndex = undefined, monthStart = undefined; i >= 1; i--) {
monthStart = monthStart ? monthStart.add({ months: -1 }) : date.add({ months: monthsInYear - 1 });
var {month, monthCode, daysInMonth} = monthStart;
assert.sameValue(`${ id } month ${ i } (code ${ monthCode }) days: ${ daysInMonth }`, `${ id } month ${ i } (code ${ monthCode }) days: ${ days[i - 1] }`);
if (monthCode.endsWith("L")) {
assert.sameValue(date.with({ monthCode }).monthCode, monthCode);
leapMonthIndex = i;
} else { } else {
if (leapMonthIndex && i === leapMonthIndex - 1) { assert.throws(RangeError, () => monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` }, { overflow: "reject" }));
var inLeapMonth = monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` });
assert.sameValue(inLeapMonth.monthCode, `${ monthCode }L`); if (i === 13) {
} 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({ 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 oneDayPastMonthEnd = monthStart.with({ day: daysInMonth + 1 });
assert.sameValue(oneDayPastMonthEnd.day, daysInMonth);
assert.throws(RangeError, () => monthStart.with({ day: daysInMonth + 1 }, { overflow: "reject" }));
}
} }
var monthDayCases = [ var monthDayCases = [
{ {
calendar: "dangi", year: 2001 + dangiYearOffset,
isoReferenceYear: 1963,
year: 2001,
month: 5, month: 5,
monthCode: "M04L", monthCode: "M04L",
day: 15 day: 15
}, },
{ {
calendar: "dangi", year: 2000 + dangiYearOffset,
isoReferenceYear: 1971,
year: 2000,
month: 6, month: 6,
day: 30 monthCode: "M06",
day: 29
}, },
]; ];
var i = 0; for (var {monthCode, month, day, year} of monthDayCases) {
for (var test of monthDayCases) { if (hasOutdatedChineseIcuData) {
var id = test.calendar; continue;
if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) { }
if (test.monthCode === undefined) var md = Temporal.PlainMonthDay.from({
test.monthCode = `M${ test.month.toString().padStart(2, "0") }`; year,
var {calendar, monthCode, month, day, year, isoReferenceYear} = test; month,
var md = Temporal.PlainMonthDay.from({ day,
year, calendar
month, });
day, var isoString = md.toString();
var mdFromIso = Temporal.PlainMonthDay.from(isoString);
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");
} }