From d83d26cc5db4ae190c3d015b83b8f377cbb0de9c Mon Sep 17 00:00:00 2001 From: Frank Tang Date: Wed, 27 Mar 2024 14:23:47 -0700 Subject: [PATCH] ICU-9972 Fix Chinese/Dangi Calendar getActualMaximum(UCAL_DAY_OF_YEAR) Also fix ICU-12620 which is mark duplicate of ICU-9972 just now. and fix ICU-22258. Separate the new year and winter solstice cache since the calculated value for these two calendar are mostly but not always the same due to slightly different observation timeZone. Remove the epochYear and zoneAstroCalc from the member data and instead return them from a getStting() method with the two caches since all four of them are constant per subclass of ChineseCalendar and do not need to be different per object. The known issues in the TestLimit is caused by both Calendar get/put the value from the same cache while the calculated result depends on the timeZone zoneAstroCalc. --- icu4c/source/i18n/chnsecal.cpp | 116 ++++++++++-------- icu4c/source/i18n/chnsecal.h | 28 ++--- icu4c/source/i18n/dangical.cpp | 22 +++- icu4c/source/i18n/dangical.h | 2 + icu4c/source/test/intltest/callimts.cpp | 53 ++------ icu4c/source/test/intltest/incaltst.cpp | 7 -- .../dev/test/calendar/IBMCalendarTest.java | 6 - 7 files changed, 110 insertions(+), 124 deletions(-) diff --git a/icu4c/source/i18n/chnsecal.cpp b/icu4c/source/i18n/chnsecal.cpp index 4154a39cc87..7db5b4800bf 100644 --- a/icu4c/source/i18n/chnsecal.cpp +++ b/icu4c/source/i18n/chnsecal.cpp @@ -24,7 +24,7 @@ #include "umutex.h" #include #include "gregoimp.h" // Math -#include "astro.h" // CalendarAstronomer +#include "astro.h" // CalendarAstronomer and CalendarCache #include "unicode/simpletz.h" #include "uhash.h" #include "ucln_in.h" @@ -117,7 +117,7 @@ namespace { const TimeZone* getAstronomerTimeZone(); int32_t newMoonNear(const TimeZone*, double, UBool); -int32_t newYear(const TimeZone* timeZone, int32_t); +int32_t newYear(const icu::ChineseCalendar::Setting&, int32_t); UBool isLeapMonthBetween(const TimeZone*, int32_t, int32_t); } // namespace @@ -128,27 +128,13 @@ ChineseCalendar* ChineseCalendar::clone() const { ChineseCalendar::ChineseCalendar(const Locale& aLocale, UErrorCode& success) : Calendar(TimeZone::forLocaleOrDefault(aLocale), aLocale, success), - hasLeapMonthBetweenWinterSolstices(false), - fEpochYear(CHINESE_EPOCH_YEAR), - fAstronomerTimeZone(getAstronomerTimeZone()) -{ - setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly. -} - -ChineseCalendar::ChineseCalendar(const Locale& aLocale, int32_t epochYear, - const TimeZone* zoneAstroCalc, UErrorCode &success) -: Calendar(TimeZone::forLocaleOrDefault(aLocale), aLocale, success), - hasLeapMonthBetweenWinterSolstices(false), - fEpochYear(epochYear), - fAstronomerTimeZone(zoneAstroCalc) + hasLeapMonthBetweenWinterSolstices(false) { setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly. } ChineseCalendar::ChineseCalendar(const ChineseCalendar& other) : Calendar(other) { hasLeapMonthBetweenWinterSolstices = other.hasLeapMonthBetweenWinterSolstices; - fEpochYear = other.fEpochYear; - fAstronomerTimeZone = other.fAstronomerTimeZone; } ChineseCalendar::~ChineseCalendar() @@ -239,12 +225,16 @@ int32_t ChineseCalendar::handleGetExtendedYear(UErrorCode& status) { // adjust to the instance specific epoch int32_t cycle = internalGet(UCAL_ERA, 1); year = internalGet(UCAL_YEAR, 1); + const Setting setting = getSetting(status); + if (U_FAILURE(status)) { + return 0; + } // Handle int32 overflow calculation for // year = year + (cycle-1) * 60 -(fEpochYear - CHINESE_EPOCH_YEAR) if (uprv_add32_overflow(cycle, -1, &cycle) || // 0-based cycle uprv_mul32_overflow(cycle, 60, &cycle) || uprv_add32_overflow(year, cycle, &year) || - uprv_add32_overflow(year, -(fEpochYear-CHINESE_EPOCH_YEAR), + uprv_add32_overflow(year, -(setting.epochYear-CHINESE_EPOCH_YEAR), &year)) { status = U_ILLEGAL_ARGUMENT_ERROR; return 0; @@ -262,13 +252,14 @@ int32_t ChineseCalendar::handleGetExtendedYear(UErrorCode& status) { * @stable ICU 2.8 */ int32_t ChineseCalendar::handleGetMonthLength(int32_t extendedYear, int32_t month, UErrorCode& status) const { + const Setting setting = getSetting(status); int32_t thisStart = handleComputeMonthStart(extendedYear, month, true, status); if (U_FAILURE(status)) { return 0; } thisStart = thisStart - kEpochStartAsJulianDay + 1; // Julian day -> local days - int32_t nextStart = newMoonNear(fAstronomerTimeZone, thisStart + SYNODIC_GAP, true); + int32_t nextStart = newMoonNear(setting.zoneAstroCalc, thisStart + SYNODIC_GAP, true); return nextStart - thisStart; } @@ -318,7 +309,9 @@ struct MonthInfo { bool isLeapMonth; bool hasLeapMonthBetweenWinterSolstices; }; -struct MonthInfo computeMonthInfo(const TimeZone* timeZone, int32_t gyear, int32_t days); +struct MonthInfo computeMonthInfo( + const icu::ChineseCalendar::Setting& setting, + int32_t gyear, int32_t days); } // namespace @@ -350,13 +343,18 @@ int64_t ChineseCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, U month = (int32_t)m; } + const Setting setting = getSetting(status); + if (U_FAILURE(status)) { + return 0; + } int32_t gyear; - if (uprv_add32_overflow(eyear, fEpochYear - 1, &gyear)) { + if (uprv_add32_overflow(eyear, setting.epochYear - 1, &gyear)) { status = U_ILLEGAL_ARGUMENT_ERROR; return 0; } - int32_t theNewYear = newYear(fAstronomerTimeZone, gyear); - int32_t newMoon = newMoonNear(fAstronomerTimeZone, theNewYear + month * 29, true); + + int32_t theNewYear = newYear(setting, gyear); + int32_t newMoon = newMoonNear(setting.zoneAstroCalc, theNewYear + month * 29, true); // Ignore IS_LEAP_MONTH field if useMonth is false bool isLeapMonth = false; @@ -370,9 +368,9 @@ int64_t ChineseCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, U int32_t unusedDayOfYear; Grego::dayToFields(newMoon, gyear, unusedMonth, unusedDayOfWeek, unusedDayOfMonth, unusedDayOfYear); - struct MonthInfo monthInfo = computeMonthInfo(fAstronomerTimeZone, gyear, newMoon); + struct MonthInfo monthInfo = computeMonthInfo(setting, gyear, newMoon); if (month != monthInfo.month-1 || isLeapMonth != monthInfo.isLeapMonth) { - newMoon = newMoonNear(fAstronomerTimeZone, newMoon + SYNODIC_GAP, true); + newMoon = newMoonNear(setting.zoneAstroCalc, newMoon + SYNODIC_GAP, true); } int32_t julianDay; if (uprv_add32_overflow(newMoon-1, kEpochStartAsJulianDay, &julianDay)) { @@ -484,12 +482,13 @@ void ChineseCalendar::roll(UCalendarDateFields field, int32_t amount, UErrorCode case UCAL_MONTH: case UCAL_ORDINAL_MONTH: if (amount != 0) { + const Setting setting = getSetting(status); int32_t day = get(UCAL_JULIAN_DAY, status) - kEpochStartAsJulianDay; // Get local day int32_t month = get(UCAL_MONTH, status); // 0-based month int32_t dayOfMonth = get(UCAL_DAY_OF_MONTH, status); bool isLeapMonth = get(UCAL_IS_LEAP_MONTH, status) == 1; if (U_FAILURE(status)) break; - struct RollMonthInfo r = rollMonth(fAstronomerTimeZone, amount, + struct RollMonthInfo r = rollMonth(setting.zoneAstroCalc, amount, day, month, dayOfMonth, isLeapMonth, hasLeapMonthBetweenWinterSolstices, status); if (U_FAILURE(status)) break; if (r.newMoon != r.month) { @@ -566,15 +565,17 @@ double millisToDays(const TimeZone* timeZone, double millis) { * Return the major solar term on or after December 15 of the given * Gregorian year, that is, the winter solstice of the given year. * Computations are relative to Asia/Shanghai time zone. - * @param timeZone time zone for the Astro calculation. + * @param setting setting (time zone and caches) for the Astro calculation. * @param gyear a Gregorian year * @return days after January 1, 1970 0:00 Asia/Shanghai of the * winter solstice of the given year */ -int32_t winterSolstice(const TimeZone* timeZone, int32_t gyear) { +int32_t winterSolstice(const icu::ChineseCalendar::Setting& setting, + int32_t gyear) { + const TimeZone* timeZone = setting.zoneAstroCalc; UErrorCode status = U_ZERO_ERROR; - int32_t cacheValue = CalendarCache::get(&gWinterSolsticeCache, gyear, status); + int32_t cacheValue = CalendarCache::get(setting.winterSolsticeCache, gyear, status); if (cacheValue == 0) { // In books December 15 is used, but it fails for some years @@ -592,7 +593,7 @@ int32_t winterSolstice(const TimeZone* timeZone, int32_t gyear) { return 0; } cacheValue = (int32_t) days; - CalendarCache::put(&gWinterSolsticeCache, gyear, cacheValue, status); + CalendarCache::put(setting.winterSolsticeCache, gyear, cacheValue, status); } if(U_FAILURE(status)) { cacheValue = 0; @@ -695,27 +696,30 @@ UBool isLeapMonthBetween(const TimeZone* timeZone, int32_t newMoon1, int32_t new /** * Compute the information about the year. - * @param timeZone time zone for the Astro calculation. + * @param setting setting (time zone and caches) for the Astro calculation. * @param gyear the Gregorian year of the given date * @param days days after January 1, 1970 0:00 astronomical base zone * of the date to compute fields for * @return The MonthInfo result. */ -struct MonthInfo computeMonthInfo(const TimeZone* timeZone, int32_t gyear, int32_t days) { +struct MonthInfo computeMonthInfo( + const icu::ChineseCalendar::Setting& setting, + int32_t gyear, int32_t days) { struct MonthInfo output; // Find the winter solstices before and after the target date. // These define the boundaries of this Chinese year, specifically, // the position of month 11, which always contains the solstice. // We want solsticeBefore <= date < solsticeAfter. int32_t solsticeBefore; - int32_t solsticeAfter = winterSolstice(timeZone, gyear); + int32_t solsticeAfter = winterSolstice(setting, gyear); if (days < solsticeAfter) { - solsticeBefore = winterSolstice(timeZone, gyear - 1); + solsticeBefore = winterSolstice(setting, gyear - 1); } else { solsticeBefore = solsticeAfter; - solsticeAfter = winterSolstice(timeZone, gyear + 1); + solsticeAfter = winterSolstice(setting, gyear + 1); } + const TimeZone* timeZone = setting.zoneAstroCalc; // Find the start of the month after month 11. This will be either // the prior month 12 or leap month 11 (very rare). Also find the // start of the following month 11. @@ -725,9 +729,9 @@ struct MonthInfo computeMonthInfo(const TimeZone* timeZone, int32_t gyear, int32 output.hasLeapMonthBetweenWinterSolstices = synodicMonthsBetween(firstMoon, lastMoon) == 12; output.month = synodicMonthsBetween(firstMoon, output.thisMoon); - int32_t theNewYear = newYear(timeZone, gyear); + int32_t theNewYear = newYear(setting, gyear); if (days < theNewYear) { - theNewYear = newYear(timeZone, gyear-1); + theNewYear = newYear(setting, gyear-1); } if (output.hasLeapMonthBetweenWinterSolstices && isLeapMonthBetween(timeZone, firstMoon, output.thisMoon)) { @@ -779,11 +783,15 @@ void ChineseCalendar::handleComputeFields(int32_t julianDay, UErrorCode & status int32_t gyear = getGregorianYear(); int32_t gmonth = getGregorianMonth(); - struct MonthInfo monthInfo = computeMonthInfo(fAstronomerTimeZone, gyear, days); + const Setting setting = getSetting(status); + if (U_FAILURE(status)) { + return; + } + struct MonthInfo monthInfo = computeMonthInfo(setting, gyear, days); hasLeapMonthBetweenWinterSolstices = monthInfo.hasLeapMonthBetweenWinterSolstices; // Extended year and cycle year is based on the epoch year - int32_t eyear = gyear - fEpochYear; + int32_t eyear = gyear - setting.epochYear; int32_t cycle_year = gyear - CHINESE_EPOCH_YEAR; if (monthInfo.month < 11 || gmonth >= UCAL_JULY) { @@ -800,9 +808,9 @@ void ChineseCalendar::handleComputeFields(int32_t julianDay, UErrorCode & status // date is in month 11, leap 11, 12. There is never a leap 12. // New year computations are cached so this should be cheap in // the long run. - int32_t theNewYear = newYear(fAstronomerTimeZone, gyear); + int32_t theNewYear = newYear(setting, gyear); if (days < theNewYear) { - theNewYear = newYear(fAstronomerTimeZone, gyear-1); + theNewYear = newYear(setting, gyear-1); } cycle++; yearOfCycle++; @@ -844,19 +852,21 @@ namespace { /** * Return the Chinese new year of the given Gregorian year. - * @param timeZone time zone for the Astro calculation. + * @param setting setting (time zone and caches) for the Astro calculation. * @param gyear a Gregorian year * @return days after January 1, 1970 0:00 astronomical base zone of the * Chinese new year of the given year (this will be a new moon) */ -int32_t newYear(const TimeZone* timeZone, int32_t gyear) { +int32_t newYear(const icu::ChineseCalendar::Setting& setting, + int32_t gyear) { + const TimeZone* timeZone = setting.zoneAstroCalc; UErrorCode status = U_ZERO_ERROR; - int32_t cacheValue = CalendarCache::get(&gNewYearCache, gyear, status); + int32_t cacheValue = CalendarCache::get(setting.newYearCache, gyear, status); if (cacheValue == 0) { - int32_t solsticeBefore= winterSolstice(timeZone, gyear - 1); - int32_t solsticeAfter = winterSolstice(timeZone, gyear); + int32_t solsticeBefore= winterSolstice(setting, gyear - 1); + int32_t solsticeAfter = winterSolstice(setting, gyear); int32_t newMoon1 = newMoonNear(timeZone, solsticeBefore + 1, true); int32_t newMoon2 = newMoonNear(timeZone, newMoon1 + SYNODIC_GAP, true); int32_t newMoon11 = newMoonNear(timeZone, solsticeAfter + 1, false); @@ -869,7 +879,7 @@ int32_t newYear(const TimeZone* timeZone, int32_t gyear) { cacheValue = newMoon2; } - CalendarCache::put(&gNewYearCache, gyear, cacheValue, status); + CalendarCache::put(setting.newYearCache, gyear, cacheValue, status); } if(U_FAILURE(status)) { cacheValue = 0; @@ -893,6 +903,7 @@ int32_t newYear(const TimeZone* timeZone, int32_t gyear) { */ void ChineseCalendar::offsetMonth(int32_t newMoon, int32_t dayOfMonth, int32_t delta, UErrorCode& status) { + const Setting setting = getSetting(status); if (U_FAILURE(status)) { return; } // Move to the middle of the month before our target month. @@ -906,7 +917,7 @@ void ChineseCalendar::offsetMonth(int32_t newMoon, int32_t dayOfMonth, int32_t d newMoon = static_cast(value); // Search forward to the target month's new moon - newMoon = newMoonNear(fAstronomerTimeZone, newMoon, true); + newMoon = newMoonNear(setting.zoneAstroCalc, newMoon, true); // Find the target dayOfMonth int32_t jd = newMoon + kEpochStartAsJulianDay - 1 + dayOfMonth; @@ -1039,6 +1050,15 @@ int32_t ChineseCalendar::internalGetMonth(int32_t defaultValue, UErrorCode& stat return internalGetMonth(status); } +ChineseCalendar::Setting ChineseCalendar::getSetting(UErrorCode&) const { + return { + CHINESE_EPOCH_YEAR, + getAstronomerTimeZone(), + &gWinterSolsticeCache, + &gNewYearCache + }; +} + U_NAMESPACE_END #endif diff --git a/icu4c/source/i18n/chnsecal.h b/icu4c/source/i18n/chnsecal.h index 6c7d40af173..41bd3557fcb 100644 --- a/icu4c/source/i18n/chnsecal.h +++ b/icu4c/source/i18n/chnsecal.h @@ -27,6 +27,7 @@ U_NAMESPACE_BEGIN +class CalendarCache; /** * ChineseCalendar is a concrete subclass of {@link Calendar} * that implements a traditional Chinese calendar. The traditional Chinese @@ -152,23 +153,6 @@ class U_I18N_API ChineseCalendar : public Calendar { */ virtual void setTemporalMonthCode(const char* code, UErrorCode& status) override; - protected: - - /** - * Constructs a ChineseCalendar based on the current time in the default time zone - * with the given locale, using the specified epoch year and time zone for - * astronomical calculations. - * - * @param aLocale The given locale. - * @param epochYear The epoch year to use for calculation. - * @param zoneAstroCalc The TimeZone to use for astronomical calculations. If null, - * will be set appropriately for Chinese calendar (UTC + 8:00). - * @param success Indicates the status of ChineseCalendar object construction; - * if successful, will not be changed to an error value. - * @internal - */ - ChineseCalendar(const Locale& aLocale, int32_t epochYear, const TimeZone* zoneAstroCalc, UErrorCode &success); - public: /** * Copy Constructor @@ -197,9 +181,6 @@ class U_I18N_API ChineseCalendar : public Calendar { // this value could be false for a date prior to the Winter Solstice of that // year but that year still has a leap month and therefor is a leap year. UBool hasLeapMonthBetweenWinterSolstices; - int32_t fEpochYear; // Start year of this Chinese calendar instance. - const TimeZone* fAstronomerTimeZone; // Zone used for the astronomical calculation - // of this Chinese calendar instance. //---------------------------------------------------------------------- // Calendar framework @@ -273,7 +254,14 @@ class U_I18N_API ChineseCalendar : public Calendar { */ virtual const char * getType() const override; + struct Setting { + int32_t epochYear; + const TimeZone* zoneAstroCalc; + CalendarCache** winterSolsticeCache; + CalendarCache** newYearCache; + }; protected: + virtual Setting getSetting(UErrorCode& status) const; virtual int32_t internalGetMonth(int32_t defaultValue, UErrorCode& status) const override; virtual int32_t internalGetMonth(UErrorCode& status) const override; diff --git a/icu4c/source/i18n/dangical.cpp b/icu4c/source/i18n/dangical.cpp index 1374a128109..e1cf6295371 100644 --- a/icu4c/source/i18n/dangical.cpp +++ b/icu4c/source/i18n/dangical.cpp @@ -15,6 +15,7 @@ #if !UCONFIG_NO_FORMATTING +#include "astro.h" // CalendarCache #include "gregoimp.h" // Math #include "uassert.h" #include "ucln_in.h" @@ -23,6 +24,10 @@ #include "unicode/tzrule.h" // --- The cache -- +// Lazy Creation & Access synchronized by class CalendarCache with a mutex. +static icu::CalendarCache *gWinterSolsticeCache = nullptr; +static icu::CalendarCache *gNewYearCache = nullptr; + // gAstronomerTimeZone static icu::TimeZone *gAstronomerTimeZone = nullptr; static icu::UInitOnce gAstronomerTimeZoneInitOnce {}; @@ -35,6 +40,15 @@ static const int32_t DANGI_EPOCH_YEAR = -2332; // Gregorian year U_CDECL_BEGIN static UBool calendar_dangi_cleanup() { + if (gWinterSolsticeCache) { + delete gWinterSolsticeCache; + gWinterSolsticeCache = nullptr; + } + if (gNewYearCache) { + delete gNewYearCache; + gNewYearCache = nullptr; + } + if (gAstronomerTimeZone) { delete gAstronomerTimeZone; gAstronomerTimeZone = nullptr; @@ -55,7 +69,7 @@ U_NAMESPACE_BEGIN const TimeZone* getAstronomerTimeZone(UErrorCode &status); DangiCalendar::DangiCalendar(const Locale& aLocale, UErrorCode& success) -: ChineseCalendar(aLocale, DANGI_EPOCH_YEAR, getAstronomerTimeZone(success), success) +: ChineseCalendar(aLocale, success) { } @@ -165,6 +179,12 @@ void DangiCalendar::setRelatedYear(int32_t year) set(UCAL_EXTENDED_YEAR, year - kDangiRelatedYearDiff); } +ChineseCalendar::Setting DangiCalendar::getSetting(UErrorCode& status) const { + return { DANGI_EPOCH_YEAR, + getAstronomerTimeZone(status), + &gWinterSolsticeCache, &gNewYearCache + }; +} UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DangiCalendar) diff --git a/icu4c/source/i18n/dangical.h b/icu4c/source/i18n/dangical.h index ccf34eb8865..bc96be2a31e 100644 --- a/icu4c/source/i18n/dangical.h +++ b/icu4c/source/i18n/dangical.h @@ -118,6 +118,8 @@ class DangiCalendar : public ChineseCalendar { */ const char * getType() const override; + protected: + virtual Setting getSetting(UErrorCode& status) const override; private: diff --git a/icu4c/source/test/intltest/callimts.cpp b/icu4c/source/test/intltest/callimts.cpp index 973da7cb11d..3ab6166ac5c 100644 --- a/icu4c/source/test/intltest/callimts.cpp +++ b/icu4c/source/test/intltest/callimts.cpp @@ -416,50 +416,19 @@ CalendarLimitTest::doLimitsTest(Calendar& cal, ", actual_min=" + minActual); } if (maxActual < maxLow || maxActual > maxHigh) { - if ( uprv_strcmp(cal.getType(), "chinese") == 0 && - testMillis >= 1802044800000.0 && - logKnownIssue("ICU-12620", "chinese calendar failures for some actualMax tests")) { - logln((UnicodeString)"KnownFail: [" + cal.getType() + "] " + - ymdToString(cal, ymd) + - " Range for max of " + FIELD_NAME[f] + "(" + f + - ")=" + maxLow + ".." + maxHigh + - ", actual_max=" + maxActual); - } else { - errln((UnicodeString)"Fail: [" + cal.getType() + "] " + - ymdToString(cal, ymd) + - " Range for max of " + FIELD_NAME[f] + "(" + f + - ")=" + maxLow + ".." + maxHigh + - ", actual_max=" + maxActual); - } + errln((UnicodeString)"Fail: [" + cal.getType() + "] " + + ymdToString(cal, ymd) + + " Range for max of " + FIELD_NAME[f] + "(" + f + + ")=" + maxLow + ".." + maxHigh + + ", actual_max=" + maxActual); } if (v < minActual || v > maxActual) { - // timebomb per #9967, fix with #9972 - if ( uprv_strcmp(cal.getType(), "dangi") == 0 && - testMillis >= 1865635198000.0 && - logKnownIssue("ICU-9972", "as per #9967")) { // Feb 2029 gregorian, end of dangi 4361 - logln((UnicodeString)"KnownFail: [" + cal.getType() + "] " + - ymdToString(cal, ymd) + - " " + FIELD_NAME[f] + "(" + f + ")=" + v + - ", actual=" + minActual + ".." + maxActual + - ", allowed=(" + minLow + ".." + minHigh + ")..(" + - maxLow + ".." + maxHigh + ")"); - } else if ( uprv_strcmp(cal.getType(), "chinese") == 0 && - testMillis >= 1832544000000.0 && - logKnownIssue("ICU-12620", "chinese calendar failures for some actualMax tests")) { - logln((UnicodeString)"KnownFail: [" + cal.getType() + "] " + - ymdToString(cal, ymd) + - " " + FIELD_NAME[f] + "(" + f + ")=" + v + - ", actual=" + minActual + ".." + maxActual + - ", allowed=(" + minLow + ".." + minHigh + ")..(" + - maxLow + ".." + maxHigh + ")"); - } else { - errln((UnicodeString)"Fail: [" + cal.getType() + "] " + - ymdToString(cal, ymd) + - " " + FIELD_NAME[f] + "(" + f + ")=" + v + - ", actual=" + minActual + ".." + maxActual + - ", allowed=(" + minLow + ".." + minHigh + ")..(" + - maxLow + ".." + maxHigh + ")"); - } + errln((UnicodeString)"Fail: [" + cal.getType() + "] " + + ymdToString(cal, ymd) + + " " + FIELD_NAME[f] + "(" + f + ")=" + v + + ", actual=" + minActual + ".." + maxActual + + ", allowed=(" + minLow + ".." + minHigh + ")..(" + + maxLow + ".." + maxHigh + ")"); } } greg.add(UCAL_DAY_OF_YEAR, 1, status); diff --git a/icu4c/source/test/intltest/incaltst.cpp b/icu4c/source/test/intltest/incaltst.cpp index 812fe4a678b..6f786c59b5a 100644 --- a/icu4c/source/test/intltest/incaltst.cpp +++ b/icu4c/source/test/intltest/incaltst.cpp @@ -1004,7 +1004,6 @@ void IntlCalendarTest::checkConsistency(const char* locale) { const char* type = base->getType(); // Do not ignore in quick mode bool ignoreOrdinaryMonth12Bug = (!quick) && (strcmp("chinese", type) == 0 || strcmp("dangi", type) == 0); - bool ignoreICU22258 = (!quick) && (strcmp("dangi", type) == 0); UDate test = Calendar::getNow(); base->setTimeZone(*(TimeZone::getGMT())); int32_t j; @@ -1100,12 +1099,6 @@ void IntlCalendarTest::checkConsistency(const char* locale) { int32_t year = base->get(UCAL_YEAR, status); int32_t month = base->get(UCAL_MONTH, status) + 1; int32_t date = base->get(UCAL_DATE, status); - if (ignoreICU22258 && (year == 4 || year == 34) && month == 12 && date == 30) { - logKnownIssue("ICU-22258", - "Dangi Problem in 1988/2/17=>4/12/30 and 1958/2/18=>34/12/30"); - status.reset(); - continue; - } errln((UnicodeString)"Round trip conversion produces different " "time from " + test + " to " + result + " delta: " + diff --git a/icu4j/main/core/src/test/java/com/ibm/icu/dev/test/calendar/IBMCalendarTest.java b/icu4j/main/core/src/test/java/com/ibm/icu/dev/test/calendar/IBMCalendarTest.java index 9322764fa4d..789161c255c 100644 --- a/icu4j/main/core/src/test/java/com/ibm/icu/dev/test/calendar/IBMCalendarTest.java +++ b/icu4j/main/core/src/test/java/com/ibm/icu/dev/test/calendar/IBMCalendarTest.java @@ -2192,7 +2192,6 @@ public class IBMCalendarTest extends CalendarTestFmwk { int lastDay = 1; String type = base.getType(); boolean ignoreOrdinaryMonth12Bug = (!quick) && (type.equals("chinese") || type.equals("dangi")); - boolean ignoreICU22258 = (!quick) && type.equals("dangi"); for (int j = 0; j < numOfDaysToTest; j++, test.setTime(test.getTime() - msInADay)) { g.setTime(test); base.clear(); @@ -2244,11 +2243,6 @@ public class IBMCalendarTest extends CalendarTestFmwk { int year = base.get(Calendar.YEAR); int month = base.get(Calendar.MONTH) + 1; int date = base.get(Calendar.DATE); - if (ignoreICU22258 && (year == 4 || year == 34) && month == 12 && date == 30) { - logKnownIssue("ICU-22258", - "Dangi Problem in 1988/2/17=>4/12/30 and 1958/2/18=>34/12/30"); - continue; - } errln("Round trip conversion produces different time from " + test + " to " + result + " delta: " + (result.getTime() - test.getTime()) +