532 lines
20 KiB
C++
532 lines
20 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/***********************************************************************
|
|
* COPYRIGHT:
|
|
* Copyright (c) 1997-2015, International Business Machines Corporation
|
|
* and others. All Rights Reserved.
|
|
***********************************************************************/
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
#include "callimts.h"
|
|
#include "caltest.h"
|
|
#include "unicode/calendar.h"
|
|
#include "unicode/gregocal.h"
|
|
#include "unicode/datefmt.h"
|
|
#include "unicode/smpdtfmt.h"
|
|
#include "cstring.h"
|
|
#include "mutex.h"
|
|
#include "putilimp.h"
|
|
#include "simplethread.h"
|
|
|
|
U_NAMESPACE_USE
|
|
void CalendarLimitTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
|
|
{
|
|
if (exec) logln("TestSuite TestCalendarLimit");
|
|
switch (index) {
|
|
// Re-enable this later
|
|
case 0:
|
|
name = "TestCalendarExtremeLimit";
|
|
if (exec) {
|
|
logln("TestCalendarExtremeLimit---"); logln("");
|
|
TestCalendarExtremeLimit();
|
|
}
|
|
break;
|
|
case 1:
|
|
name = "TestLimits";
|
|
if (exec) {
|
|
logln("TestLimits---"); logln("");
|
|
TestLimits();
|
|
}
|
|
break;
|
|
|
|
default: name = ""; break;
|
|
}
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// class CalendarLimitTest
|
|
// *****************************************************************************
|
|
|
|
// -------------------------------------
|
|
void
|
|
CalendarLimitTest::test(UDate millis, icu::Calendar* cal, icu::DateFormat* fmt)
|
|
{
|
|
static const UDate kDrift = 1e-10;
|
|
UErrorCode exception = U_ZERO_ERROR;
|
|
UnicodeString theDate;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
cal->setTime(millis, exception);
|
|
if (U_SUCCESS(exception)) {
|
|
fmt->format(millis, theDate);
|
|
UDate dt = fmt->parse(theDate, status);
|
|
// allow a small amount of error (drift)
|
|
if(! withinErr(dt, millis, kDrift)) {
|
|
errln("FAIL:round trip for large milli, got: %.1lf wanted: %.1lf. (delta %.2lf greater than %.2lf)",
|
|
dt, millis, uprv_fabs(millis-dt), uprv_fabs(dt*kDrift));
|
|
logln(UnicodeString(" ") + theDate + " " + CalendarTest::calToStr(*cal));
|
|
} else {
|
|
logln(UnicodeString("OK: got ") + dt + ", wanted " + millis);
|
|
logln(UnicodeString(" ") + theDate);
|
|
}
|
|
}
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
// bug 986c: deprecate nextDouble/previousDouble
|
|
//|double
|
|
//|CalendarLimitTest::nextDouble(double a)
|
|
//|{
|
|
//| return uprv_nextDouble(a, TRUE);
|
|
//|}
|
|
//|
|
|
//|double
|
|
//|CalendarLimitTest::previousDouble(double a)
|
|
//|{
|
|
//| return uprv_nextDouble(a, FALSE);
|
|
//|}
|
|
|
|
UBool
|
|
CalendarLimitTest::withinErr(double a, double b, double err)
|
|
{
|
|
return ( uprv_fabs(a - b) < uprv_fabs(a * err) );
|
|
}
|
|
|
|
void
|
|
CalendarLimitTest::TestCalendarExtremeLimit()
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
Calendar *cal = Calendar::createInstance(status);
|
|
if (failure(status, "Calendar::createInstance", TRUE)) return;
|
|
cal->adoptTimeZone(TimeZone::createTimeZone("GMT"));
|
|
DateFormat *fmt = DateFormat::createDateTimeInstance();
|
|
if(!fmt || !cal) {
|
|
dataerrln("can't open cal and/or fmt");
|
|
return;
|
|
}
|
|
fmt->adoptCalendar(cal);
|
|
((SimpleDateFormat*) fmt)->applyPattern("HH:mm:ss.SSS Z, EEEE, MMMM d, yyyy G");
|
|
|
|
|
|
// This test used to test the algorithmic limits of the dates that
|
|
// GregorianCalendar could handle. However, the algorithm has
|
|
// been rewritten completely since then and the prior limits no
|
|
// longer apply. Instead, we now do basic round-trip testing of
|
|
// some extreme (but still manageable) dates.
|
|
UDate m;
|
|
logln("checking 1e16..1e17");
|
|
for ( m = 1e16; m < 1e17; m *= 1.1) {
|
|
test(m, cal, fmt);
|
|
}
|
|
logln("checking -1e14..-1e15");
|
|
for ( m = -1e14; m > -1e15; m *= 1.1) {
|
|
test(m, cal, fmt);
|
|
}
|
|
|
|
// This is 2^52 - 1, the largest allowable mantissa with a 0
|
|
// exponent in a 64-bit double
|
|
UDate VERY_EARLY_MILLIS = - 4503599627370495.0;
|
|
UDate VERY_LATE_MILLIS = 4503599627370495.0;
|
|
|
|
// I am removing the previousDouble and nextDouble calls below for
|
|
// two reasons: 1. As part of jitterbug 986, I am deprecating
|
|
// these methods and removing calls to them. 2. This test is a
|
|
// non-critical boundary behavior test.
|
|
test(VERY_EARLY_MILLIS, cal, fmt);
|
|
//test(previousDouble(VERY_EARLY_MILLIS), cal, fmt);
|
|
test(VERY_LATE_MILLIS, cal, fmt);
|
|
//test(nextDouble(VERY_LATE_MILLIS), cal, fmt);
|
|
delete fmt;
|
|
}
|
|
|
|
namespace {
|
|
|
|
struct TestCase {
|
|
const char *type;
|
|
UBool hasLeapMonth;
|
|
UDate actualTestStart;
|
|
int32_t actualTestEnd;
|
|
};
|
|
|
|
const UDate DEFAULT_START = 944006400000.0; // 1999-12-01T00:00Z
|
|
const int32_t DEFAULT_END = -120; // Default for non-quick is run 2 minutes
|
|
|
|
TestCase TestCases[] = {
|
|
{"gregorian", FALSE, DEFAULT_START, DEFAULT_END},
|
|
{"japanese", FALSE, 596937600000.0, DEFAULT_END}, // 1988-12-01T00:00Z, Showa 63
|
|
{"buddhist", FALSE, DEFAULT_START, DEFAULT_END},
|
|
{"roc", FALSE, DEFAULT_START, DEFAULT_END},
|
|
{"persian", FALSE, DEFAULT_START, DEFAULT_END},
|
|
{"islamic-civil", FALSE, DEFAULT_START, DEFAULT_END},
|
|
{"islamic", FALSE, DEFAULT_START, 800000}, // Approx. 2250 years from now, after which
|
|
// some rounding errors occur in Islamic calendar
|
|
{"hebrew", TRUE, DEFAULT_START, DEFAULT_END},
|
|
{"chinese", TRUE, DEFAULT_START, DEFAULT_END},
|
|
{"dangi", TRUE, DEFAULT_START, DEFAULT_END},
|
|
{"indian", FALSE, DEFAULT_START, DEFAULT_END},
|
|
{"coptic", FALSE, DEFAULT_START, DEFAULT_END},
|
|
{"ethiopic", FALSE, DEFAULT_START, DEFAULT_END},
|
|
{"ethiopic-amete-alem", FALSE, DEFAULT_START, DEFAULT_END}
|
|
};
|
|
|
|
struct {
|
|
int32_t fIndex;
|
|
UBool next (int32_t &rIndex) {
|
|
Mutex lock;
|
|
if (fIndex >= UPRV_LENGTHOF(TestCases)) {
|
|
return FALSE;
|
|
}
|
|
rIndex = fIndex++;
|
|
return TRUE;
|
|
}
|
|
void reset() {
|
|
fIndex = 0;
|
|
}
|
|
} gTestCaseIterator;
|
|
|
|
} // anonymous name space
|
|
|
|
void
|
|
CalendarLimitTest::TestLimits(void) {
|
|
gTestCaseIterator.reset();
|
|
|
|
ThreadPool<CalendarLimitTest> threads(this, threadCount, &CalendarLimitTest::TestLimitsThread);
|
|
threads.start();
|
|
threads.join();
|
|
}
|
|
|
|
|
|
void CalendarLimitTest::TestLimitsThread(int32_t threadNum) {
|
|
logln("thread %d starting", threadNum);
|
|
int32_t testIndex = 0;
|
|
LocalPointer<Calendar> cal;
|
|
while (gTestCaseIterator.next(testIndex)) {
|
|
TestCase &testCase = TestCases[testIndex];
|
|
logln("begin test of %s calendar.", testCase.type);
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
char buf[64];
|
|
uprv_strcpy(buf, "root@calendar=");
|
|
strcat(buf, testCase.type);
|
|
cal.adoptInstead(Calendar::createInstance(buf, status));
|
|
if (failure(status, "Calendar::createInstance", TRUE)) {
|
|
continue;
|
|
}
|
|
if (uprv_strcmp(cal->getType(), testCase.type) != 0) {
|
|
errln((UnicodeString)"FAIL: Wrong calendar type: " + cal->getType()
|
|
+ " Requested: " + testCase.type);
|
|
continue;
|
|
}
|
|
doTheoreticalLimitsTest(*(cal.getAlias()), testCase.hasLeapMonth);
|
|
doLimitsTest(*(cal.getAlias()), testCase.actualTestStart, testCase.actualTestEnd);
|
|
logln("end test of %s calendar.", testCase.type);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
CalendarLimitTest::doTheoreticalLimitsTest(Calendar& cal, UBool leapMonth) {
|
|
const char* calType = cal.getType();
|
|
|
|
int32_t nDOW = cal.getMaximum(UCAL_DAY_OF_WEEK);
|
|
int32_t maxDOY = cal.getMaximum(UCAL_DAY_OF_YEAR);
|
|
int32_t lmaxDOW = cal.getLeastMaximum(UCAL_DAY_OF_YEAR);
|
|
int32_t maxWOY = cal.getMaximum(UCAL_WEEK_OF_YEAR);
|
|
int32_t lmaxWOY = cal.getLeastMaximum(UCAL_WEEK_OF_YEAR);
|
|
int32_t maxM = cal.getMaximum(UCAL_MONTH) + 1;
|
|
int32_t lmaxM = cal.getLeastMaximum(UCAL_MONTH) + 1;
|
|
int32_t maxDOM = cal.getMaximum(UCAL_DAY_OF_MONTH);
|
|
int32_t lmaxDOM = cal.getLeastMaximum(UCAL_DAY_OF_MONTH);
|
|
int32_t maxDOWIM = cal.getMaximum(UCAL_DAY_OF_WEEK_IN_MONTH);
|
|
int32_t lmaxDOWIM = cal.getLeastMaximum(UCAL_DAY_OF_WEEK_IN_MONTH);
|
|
int32_t maxWOM = cal.getMaximum(UCAL_WEEK_OF_MONTH);
|
|
int32_t lmaxWOM = cal.getLeastMaximum(UCAL_WEEK_OF_MONTH);
|
|
int32_t minDaysInFirstWeek = cal.getMinimalDaysInFirstWeek();
|
|
|
|
// Day of year
|
|
int32_t expected;
|
|
if (!leapMonth) {
|
|
expected = maxM*maxDOM;
|
|
if (maxDOY > expected) {
|
|
errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of DAY_OF_YEAR is too big: "
|
|
+ maxDOY + "/expected: <=" + expected);
|
|
}
|
|
expected = lmaxM*lmaxDOM;
|
|
if (lmaxDOW < expected) {
|
|
errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of DAY_OF_YEAR is too small: "
|
|
+ lmaxDOW + "/expected: >=" + expected);
|
|
}
|
|
}
|
|
|
|
// Week of year
|
|
expected = maxDOY/nDOW + 1;
|
|
if (maxWOY > expected) {
|
|
errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of WEEK_OF_YEAR is too big: "
|
|
+ maxWOY + "/expected: <=" + expected);
|
|
}
|
|
expected = lmaxDOW/nDOW;
|
|
if (lmaxWOY < expected) {
|
|
errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of WEEK_OF_YEAR is too small: "
|
|
+ lmaxWOY + "/expected >=" + expected);
|
|
}
|
|
|
|
// Day of week in month
|
|
expected = (maxDOM + nDOW - 1)/nDOW;
|
|
if (maxDOWIM != expected) {
|
|
errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of DAY_OF_WEEK_IN_MONTH is incorrect: "
|
|
+ maxDOWIM + "/expected: " + expected);
|
|
}
|
|
expected = (lmaxDOM + nDOW - 1)/nDOW;
|
|
if (lmaxDOWIM != expected) {
|
|
errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of DAY_OF_WEEK_IN_MONTH is incorrect: "
|
|
+ lmaxDOWIM + "/expected: " + expected);
|
|
}
|
|
|
|
// Week of month
|
|
expected = (maxDOM + (nDOW - 1) + (nDOW - minDaysInFirstWeek)) / nDOW;
|
|
if (maxWOM != expected) {
|
|
errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of WEEK_OF_MONTH is incorrect: "
|
|
+ maxWOM + "/expected: " + expected);
|
|
}
|
|
expected = (lmaxDOM + (nDOW - minDaysInFirstWeek)) / nDOW;
|
|
if (lmaxWOM != expected) {
|
|
errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of WEEK_OF_MONTH is incorrect: "
|
|
+ lmaxWOM + "/expected: " + expected);
|
|
}
|
|
}
|
|
|
|
void
|
|
CalendarLimitTest::doLimitsTest(Calendar& cal, UDate startDate, int32_t endTime) {
|
|
int32_t testTime = quick ? ( endTime / 40 ) : endTime;
|
|
doLimitsTest(cal, NULL /*default fields*/, startDate, testTime);
|
|
}
|
|
|
|
void
|
|
CalendarLimitTest::doLimitsTest(Calendar& cal,
|
|
const int32_t* fieldsToTest,
|
|
UDate startDate,
|
|
int32_t testDuration) {
|
|
static const int32_t FIELDS[] = {
|
|
UCAL_ERA,
|
|
UCAL_YEAR,
|
|
UCAL_MONTH,
|
|
UCAL_WEEK_OF_YEAR,
|
|
UCAL_WEEK_OF_MONTH,
|
|
UCAL_DAY_OF_MONTH,
|
|
UCAL_DAY_OF_YEAR,
|
|
UCAL_DAY_OF_WEEK_IN_MONTH,
|
|
UCAL_YEAR_WOY,
|
|
UCAL_EXTENDED_YEAR,
|
|
-1,
|
|
};
|
|
|
|
static const char* FIELD_NAME[] = {
|
|
"ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH",
|
|
"DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK",
|
|
"DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR", "HOUR_OF_DAY",
|
|
"MINUTE", "SECOND", "MILLISECOND", "ZONE_OFFSET",
|
|
"DST_OFFSET", "YEAR_WOY", "DOW_LOCAL", "EXTENDED_YEAR",
|
|
"JULIAN_DAY", "MILLISECONDS_IN_DAY",
|
|
"IS_LEAP_MONTH"
|
|
};
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
int32_t i, j;
|
|
UnicodeString ymd;
|
|
|
|
GregorianCalendar greg(status);
|
|
if (failure(status, "new GregorianCalendar")) {
|
|
return;
|
|
}
|
|
greg.setTime(startDate, status);
|
|
if (failure(status, "GregorianCalendar::setTime")) {
|
|
return;
|
|
}
|
|
logln((UnicodeString)"Start: " + startDate);
|
|
|
|
if (fieldsToTest == NULL) {
|
|
fieldsToTest = FIELDS;
|
|
}
|
|
|
|
|
|
// Keep a record of minima and maxima that we actually see.
|
|
// These are kept in an array of arrays of hashes.
|
|
int32_t limits[UCAL_FIELD_COUNT][4];
|
|
for (j = 0; j < UCAL_FIELD_COUNT; j++) {
|
|
limits[j][0] = INT32_MAX;
|
|
limits[j][1] = INT32_MIN;
|
|
limits[j][2] = INT32_MAX;
|
|
limits[j][3] = INT32_MIN;
|
|
}
|
|
|
|
// This test can run for a long time; show progress.
|
|
UDate millis = ucal_getNow();
|
|
UDate mark = millis + 5000; // 5 sec
|
|
millis -= testDuration * 1000; // stop time if testDuration<0
|
|
|
|
for (i = 0;
|
|
testDuration > 0 ? i < testDuration
|
|
: ucal_getNow() < millis;
|
|
++i) {
|
|
if (ucal_getNow() >= mark) {
|
|
logln((UnicodeString)"(" + i + " days)");
|
|
mark += 5000; // 5 sec
|
|
}
|
|
UDate testMillis = greg.getTime(status);
|
|
cal.setTime(testMillis, status);
|
|
cal.setMinimalDaysInFirstWeek(1);
|
|
if (failure(status, "Calendar set/getTime")) {
|
|
return;
|
|
}
|
|
for (j = 0; fieldsToTest[j] >= 0; ++j) {
|
|
UCalendarDateFields f = (UCalendarDateFields)fieldsToTest[j];
|
|
int32_t v = cal.get(f, status);
|
|
int32_t minActual = cal.getActualMinimum(f, status);
|
|
int32_t maxActual = cal.getActualMaximum(f, status);
|
|
int32_t minLow = cal.getMinimum(f);
|
|
int32_t minHigh = cal.getGreatestMinimum(f);
|
|
int32_t maxLow = cal.getLeastMaximum(f);
|
|
int32_t maxHigh = cal.getMaximum(f);
|
|
|
|
if (limits[j][0] > minActual) {
|
|
// the minimum
|
|
limits[j][0] = minActual;
|
|
}
|
|
if (limits[j][1] < minActual) {
|
|
// the greatest minimum
|
|
limits[j][1] = minActual;
|
|
}
|
|
if (limits[j][2] > maxActual) {
|
|
// the least maximum
|
|
limits[j][2] = maxActual;
|
|
}
|
|
if (limits[j][3] < maxActual) {
|
|
// the maximum
|
|
limits[j][3] = maxActual;
|
|
}
|
|
|
|
if (minActual < minLow || minActual > minHigh) {
|
|
errln((UnicodeString)"Fail: [" + cal.getType() + "] " +
|
|
ymdToString(cal, ymd) +
|
|
" Range for min of " + FIELD_NAME[f] + "(" + f +
|
|
")=" + minLow + ".." + minHigh +
|
|
", actual_min=" + minActual);
|
|
}
|
|
if (maxActual < maxLow || maxActual > maxHigh) {
|
|
if ( uprv_strcmp(cal.getType(), "chinese") == 0 &&
|
|
testMillis >= 1802044800000.0 &&
|
|
logKnownIssue("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);
|
|
}
|
|
}
|
|
if (v < minActual || v > maxActual) {
|
|
// timebomb per #9967, fix with #9972
|
|
if ( uprv_strcmp(cal.getType(), "dangi") == 0 &&
|
|
testMillis >= 1865635198000.0 &&
|
|
logKnownIssue("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("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 + ")");
|
|
}
|
|
}
|
|
}
|
|
greg.add(UCAL_DAY_OF_YEAR, 1, status);
|
|
if (failure(status, "Calendar::add")) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Check actual maxima and minima seen against ranges returned
|
|
// by API.
|
|
UnicodeString buf;
|
|
for (j = 0; fieldsToTest[j] >= 0; ++j) {
|
|
int32_t rangeLow, rangeHigh;
|
|
UBool fullRangeSeen = TRUE;
|
|
UCalendarDateFields f = (UCalendarDateFields)fieldsToTest[j];
|
|
|
|
buf.remove();
|
|
buf.append((UnicodeString)"[" + cal.getType() + "] " + FIELD_NAME[f]);
|
|
|
|
// Minumum
|
|
rangeLow = cal.getMinimum(f);
|
|
rangeHigh = cal.getGreatestMinimum(f);
|
|
if (limits[j][0] != rangeLow || limits[j][1] != rangeHigh) {
|
|
fullRangeSeen = FALSE;
|
|
}
|
|
buf.append((UnicodeString)" minima range=" + rangeLow + ".." + rangeHigh);
|
|
buf.append((UnicodeString)" minima actual=" + limits[j][0] + ".." + limits[j][1]);
|
|
|
|
// Maximum
|
|
rangeLow = cal.getLeastMaximum(f);
|
|
rangeHigh = cal.getMaximum(f);
|
|
if (limits[j][2] != rangeLow || limits[j][3] != rangeHigh) {
|
|
fullRangeSeen = FALSE;
|
|
}
|
|
buf.append((UnicodeString)" maxima range=" + rangeLow + ".." + rangeHigh);
|
|
buf.append((UnicodeString)" maxima actual=" + limits[j][2] + ".." + limits[j][3]);
|
|
|
|
if (fullRangeSeen) {
|
|
logln((UnicodeString)"OK: " + buf);
|
|
} else {
|
|
// This may or may not be an error -- if the range of dates
|
|
// we scan over doesn't happen to contain a minimum or
|
|
// maximum, it doesn't mean some other range won't.
|
|
logln((UnicodeString)"Warning: " + buf);
|
|
}
|
|
}
|
|
|
|
logln((UnicodeString)"End: " + greg.getTime(status));
|
|
}
|
|
|
|
UnicodeString&
|
|
CalendarLimitTest::ymdToString(const Calendar& cal, UnicodeString& str) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
str.remove();
|
|
str.append((UnicodeString)"" + cal.get(UCAL_EXTENDED_YEAR, status)
|
|
+ "/" + (cal.get(UCAL_MONTH, status) + 1)
|
|
+ (cal.get(UCAL_IS_LEAP_MONTH, status) == 1 ? "(leap)" : "")
|
|
+ "/" + cal.get(UCAL_DATE, status)
|
|
+ " " + cal.get(UCAL_HOUR_OF_DAY, status)
|
|
+ ":" + cal.get(UCAL_MINUTE, status)
|
|
+ " zone(hrs) " + cal.get(UCAL_ZONE_OFFSET, status)/(60.0*60.0*1000.0)
|
|
+ " dst(hrs) " + cal.get(UCAL_DST_OFFSET, status)/(60.0*60.0*1000.0)
|
|
+ ", time(millis)=" + cal.getTime(status));
|
|
return str;
|
|
}
|
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|
|
|
|
// eof
|