icuSources/test/intltest/dtfmtrtts.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /***********************************************************************
   4  * COPYRIGHT:
   5  * Copyright (c) 1997-2015, International Business Machines Corporation
   6  * and others. All Rights Reserved.
   7  ***********************************************************************/
   8
   9 #include "unicode/utypes.h"
  10
  11 #if !UCONFIG_NO_FORMATTING
  12
  13 #include "unicode/datefmt.h"
  14 #include "unicode/smpdtfmt.h"
  15 #include "unicode/gregocal.h"
  16 #include "dtfmtrtts.h"
  17 #include "caltest.h"
  18 #include "cstring.h"
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22
  23 // *****************************************************************************
  24 // class DateFormatRoundTripTest
  25 // *****************************************************************************
  26
  27 // Useful for turning up subtle bugs: Change the following to TRUE, recompile,
  28 // and run while at lunch.
  29 // Warning -- makes test run infinite loop!!!
  30 #ifndef INFINITE
  31 #define INFINITE 0
  32 #endif
  33
  34 // Define this to test just a single locale
  35 //#define TEST_ONE_LOC  "cs_CZ"
  36
  37 // If SPARSENESS is > 0, we don't run each exhaustive possibility.
  38 // There are 24 total possible tests per each locale.  A SPARSENESS
  39 // of 12 means we run half of them.  A SPARSENESS of 23 means we run
  40 // 1 of them.  SPARSENESS _must_ be in the range 0..23.
  41 int32_t DateFormatRoundTripTest::SPARSENESS = 0;
  42 int32_t DateFormatRoundTripTest::TRIALS = 4;
  43 int32_t DateFormatRoundTripTest::DEPTH = 5;
  44
  45 DateFormatRoundTripTest::DateFormatRoundTripTest() : dateFormat(0) {
  46 }
  47
  48 DateFormatRoundTripTest::~DateFormatRoundTripTest() {
  49     delete dateFormat;
  50 }
  51
  52 #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break;
  53
  54 void
  55 DateFormatRoundTripTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )
  56 {
  57     optionv = (par && *par=='v');
  58     switch (index) {
  59         CASE(0,TestDateFormatRoundTrip)
  60         CASE(1, TestCentury)
  61         default: name = ""; break;
  62     }
  63 }
  64
  65 UBool
  66 DateFormatRoundTripTest::failure(UErrorCode status, const char* msg)
  67 {
  68     if(U_FAILURE(status)) {
  69         errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status));
  70         return TRUE;
  71     }
  72
  73     return FALSE;
  74 }
  75
  76 UBool
  77 DateFormatRoundTripTest::failure(UErrorCode status, const char* msg, const UnicodeString& str)
  78 {
  79     if(U_FAILURE(status)) {
  80         UnicodeString escaped;
  81         escape(str,escaped);
  82         errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status) + ", str=" + escaped);
  83         return TRUE;
  84     }
  85
  86     return FALSE;
  87 }
  88
  89 void DateFormatRoundTripTest::TestCentury()
  90 {
  91     UErrorCode status = U_ZERO_ERROR;
  92     Locale locale("es_PA");
  93     UnicodeString pattern = "MM/dd/yy hh:mm:ss a z";
  94     SimpleDateFormat fmt(pattern, locale, status);
  95     if (U_FAILURE(status)) {
  96         dataerrln("Fail: construct SimpleDateFormat: %s", u_errorName(status));
  97         return;
  98     }
  99     UDate date[] = {-55018555891590.05, 0, 0};
 100     UnicodeString result[2];
 101
 102     fmt.format(date[0], result[0]);
 103     date[1] = fmt.parse(result[0], status);
 104     fmt.format(date[1], result[1]);
 105     date[2] = fmt.parse(result[1], status);
 106
 107     /* This test case worked OK by accident before.  date[1] != date[0],
 108      * because we use -80/+20 year window for 2-digit year parsing.
 109      * (date[0] is in year 1926, date[1] is in year 2026.)  result[1] set
 110      * by the first format call returns "07/13/26 07:48:28 p.m. PST",
 111      * which is correct, because DST was not used in year 1926 in zone
 112      * America/Los_Angeles.  When this is parsed, date[1] becomes a time
 113      * in 2026, which is "07/13/26 08:48:28 p.m. PDT".  There was a zone
 114      * offset calculation bug that observed DST in 1926, which was resolved.
 115      * Before the bug was resolved, result[0] == result[1] was true,
 116      * but after the bug fix, the expected result is actually
 117      * result[0] != result[1]. -Yoshito
 118      */
 119     /* TODO: We need to review this code and clarify what we really
 120      * want to test here.
 121      */
 122     //if (date[1] != date[2] || result[0] != result[1]) {
 123     if (date[1] != date[2]) {
 124         errln("Round trip failure: \"%S\" (%f), \"%S\" (%f)", result[0].getBuffer(), date[1], result[1].getBuffer(), date[2]);
 125     }
 126 }
 127
 128 // ==
 129
 130 void DateFormatRoundTripTest::TestDateFormatRoundTrip()
 131 {
 132     UErrorCode status = U_ZERO_ERROR;
 133
 134     getFieldCal = Calendar::createInstance(status);
 135     if (U_FAILURE(status)) {
 136         dataerrln("Fail: Calendar::createInstance: %s", u_errorName(status));
 137         return;
 138     }
 139
 140
 141     int32_t locCount = 0;
 142     const Locale *avail = DateFormat::getAvailableLocales(locCount);
 143     logln("DateFormat available locales: %d", locCount);
 144     if(quick) {
 145         SPARSENESS = 18;
 146         logln("Quick mode: only testing SPARSENESS = 18");
 147     }
 148     TimeZone *tz = TimeZone::createDefault();
 149     UnicodeString temp;
 150     logln("Default TimeZone:             " + tz->getID(temp));
 151     delete tz;
 152
 153 #ifdef TEST_ONE_LOC // define this to just test ONE locale.
 154     Locale loc(TEST_ONE_LOC);
 155     test(loc);
 156 #if INFINITE
 157     for(;;) {
 158       test(loc);
 159     }
 160 #endif
 161
 162 #else
 163 # if INFINITE
 164     // Special infinite loop test mode for finding hard to reproduce errors
 165     Locale loc = Locale::getDefault();
 166     logln("ENTERING INFINITE TEST LOOP FOR Locale: " + loc.getDisplayName(temp));
 167     for(;;)
 168         test(loc);
 169 # else
 170     test(Locale::getDefault());
 171
 172 #if 1
 173     // installed locales
 174     for (int i=0; i < locCount; ++i) {
 175         test(avail[i]);
 176     }
 177 #endif
 178
 179 #if 1
 180     // special locales
 181     int32_t jCount = CalendarTest::testLocaleCount();
 182     for (int32_t j=0; j < jCount; ++j) {
 183         test(Locale(CalendarTest::testLocaleID(j)));
 184     }
 185 #endif
 186
 187 # endif
 188 #endif
 189
 190     delete getFieldCal;
 191 }
 192
 193 static const char *styleName(DateFormat::EStyle s)
 194 {
 195     switch(s)
 196     {
 197     case DateFormat::SHORT: return "SHORT";
 198     case DateFormat::MEDIUM: return "MEDIUM";
 199     case DateFormat::LONG: return "LONG";
 200     case DateFormat::FULL: return "FULL";
 201 //  case DateFormat::DEFAULT: return "DEFAULT";
 202     case DateFormat::DATE_OFFSET: return "DATE_OFFSET";
 203     case DateFormat::NONE: return "NONE";
 204     case DateFormat::DATE_TIME: return "DATE_TIME";
 205     default: return "Unknown";
 206     }
 207 }
 208
 209 void DateFormatRoundTripTest::test(const Locale& loc)
 210 {
 211     UnicodeString temp;
 212 #if !INFINITE
 213     logln("Locale: " + loc.getDisplayName(temp));
 214 #endif
 215
 216     // Total possibilities = 24
 217     //  4 date
 218     //  4 time
 219     //  16 date-time
 220     UBool TEST_TABLE [24];//= new boolean[24];
 221     int32_t i = 0;
 222     for(i = 0; i < 24; ++i)
 223         TEST_TABLE[i] = TRUE;
 224
 225     // If we have some sparseness, implement it here.  Sparseness decreases
 226     // test time by eliminating some tests, up to 23.
 227     for(i = 0; i < SPARSENESS; ) {
 228         int random = (int)(randFraction() * 24);
 229         if (random >= 0 && random < 24 && TEST_TABLE[i]) {
 230             TEST_TABLE[i] = FALSE;
 231             ++i;
 232         }
 233     }
 234
 235     int32_t itable = 0;
 236     int32_t style = 0;
 237     for(style = DateFormat::FULL; style <= DateFormat::SHORT; ++style) {
 238         if(TEST_TABLE[itable++]) {
 239             logln("Testing style " + UnicodeString(styleName((DateFormat::EStyle)style)));
 240             DateFormat *df = DateFormat::createDateInstance((DateFormat::EStyle)style, loc);
 241             if(df == NULL) {
 242               errln(UnicodeString("Could not DF::createDateInstance ") + UnicodeString(styleName((DateFormat::EStyle)style)) +      " Locale: " + loc.getDisplayName(temp));
 243             } else {
 244               test(df, loc);
 245               delete df;
 246             }
 247         }
 248     }
 249
 250     for(style = DateFormat::FULL; style <= DateFormat::SHORT; ++style) {
 251         if (TEST_TABLE[itable++]) {
 252             logln("Testing style " + UnicodeString(styleName((DateFormat::EStyle)style)));
 253             DateFormat *df = DateFormat::createTimeInstance((DateFormat::EStyle)style, loc);
 254             if(df == NULL) {
 255               errln(UnicodeString("Could not DF::createTimeInstance ") + UnicodeString(styleName((DateFormat::EStyle)style)) + " Locale: " + loc.getDisplayName(temp));
 256             } else {
 257               test(df, loc, TRUE);
 258               delete df;
 259             }
 260         }
 261     }
 262
 263     for(int32_t dstyle = DateFormat::FULL; dstyle <= DateFormat::SHORT; ++dstyle) {
 264         for(int32_t tstyle = DateFormat::FULL; tstyle <= DateFormat::SHORT; ++tstyle) {
 265             if(TEST_TABLE[itable++]) {
 266                 logln("Testing dstyle" + UnicodeString(styleName((DateFormat::EStyle)dstyle)) + ", tstyle" + UnicodeString(styleName((DateFormat::EStyle)tstyle)) );
 267                 DateFormat *df = DateFormat::createDateTimeInstance((DateFormat::EStyle)dstyle, (DateFormat::EStyle)tstyle, loc);
 268                 if(df == NULL) {
 269                     dataerrln(UnicodeString("Could not DF::createDateTimeInstance ") + UnicodeString(styleName((DateFormat::EStyle)dstyle)) + ", tstyle" + UnicodeString(styleName((DateFormat::EStyle)tstyle))    + "Locale: " + loc.getDisplayName(temp));
 270                 } else {
 271                     test(df, loc);
 272                     delete df;
 273                 }
 274             }
 275         }
 276     }
 277 }
 278
 279 void DateFormatRoundTripTest::test(DateFormat *fmt, const Locale &origLocale, UBool timeOnly)
 280 {
 281     UnicodeString pat;
 282     if(fmt->getDynamicClassID() != SimpleDateFormat::getStaticClassID()) {
 283         errln("DateFormat wasn't a SimpleDateFormat");
 284         return;
 285     }
 286
 287     UBool isGregorian = FALSE;
 288     UErrorCode minStatus = U_ZERO_ERROR;
 289     if(fmt->getCalendar() == NULL) {
 290       errln((UnicodeString)"DateFormatRoundTripTest::test, DateFormat getCalendar() returns null for " + origLocale.getName());
 291       return;
 292     }
 293     UDate minDate = CalendarTest::minDateOfCalendar(*fmt->getCalendar(), isGregorian, minStatus);
 294     if(U_FAILURE(minStatus)) {
 295       errln((UnicodeString)"Failure getting min date for " + origLocale.getName());
 296       return;
 297     }
 298     //logln(UnicodeString("Min date is ") + fullFormat(minDate)  + " for " + origLocale.getName());
 299
 300     pat = ((SimpleDateFormat*)fmt)->toPattern(pat);
 301
 302     // NOTE TO MAINTAINER
 303     // This indexOf check into the pattern needs to be refined to ignore
 304     // quoted characters.  Currently, this isn't a problem with the locale
 305     // patterns we have, but it may be a problem later.
 306
 307     UBool hasEra = (pat.indexOf(UnicodeString("G")) != -1);
 308     UBool hasZoneDisplayName = (pat.indexOf(UnicodeString("z")) != -1) || (pat.indexOf(UnicodeString("v")) != -1)
 309         || (pat.indexOf(UnicodeString("V")) != -1);
 310
 311     // Because patterns contain incomplete data representing the Date,
 312     // we must be careful of how we do the roundtrip.  We start with
 313     // a randomly generated Date because they're easier to generate.
 314     // From this we get a string.  The string is our real starting point,
 315     // because this string should parse the same way all the time.  Note
 316     // that it will not necessarily parse back to the original date because
 317     // of incompleteness in patterns.  For example, a time-only pattern won't
 318     // parse back to the same date.
 319
 320     //try {
 321         for(int i = 0; i < TRIALS; ++i) {
 322             UDate *d                = new UDate    [DEPTH];
 323             UnicodeString *s    = new UnicodeString[DEPTH];
 324
 325             if(isGregorian == TRUE) {
 326               d[0] = generateDate();
 327             } else {
 328               d[0] = generateDate(minDate);
 329             }
 330
 331             UErrorCode status = U_ZERO_ERROR;
 332
 333             // We go through this loop until we achieve a match or until
 334             // the maximum loop count is reached.  We record the points at
 335             // which the date and the string starts to match.  Once matching
 336             // starts, it should continue.
 337             int loop;
 338             int dmatch = 0; // d[dmatch].getTime() == d[dmatch-1].getTime()
 339             int smatch = 0; // s[smatch].equals(s[smatch-1])
 340             for(loop = 0; loop < DEPTH; ++loop) {
 341                 if (loop > 0)  {
 342                     d[loop] = fmt->parse(s[loop-1], status);
 343                     if(U_FAILURE(status)) {
 344                         ParsePosition ppos;
 345                         (void)fmt->parse(s[loop-1], ppos);
 346                         failure(status, "fmt->parse", s[loop-1]+" in locale: " + origLocale.getName() +
 347                                 " with pattern: " + pat + " has errIndex: " + ppos.getErrorIndex());
 348                         status = U_ZERO_ERROR; /* any error would have been reported */
 349                     }
 350                 }
 351
 352                 s[loop] = fmt->format(d[loop], s[loop]);
 353
 354                 // For displaying which date is being tested
 355                 //logln(s[loop] + " = " + fullFormat(d[loop]));
 356
 357                 if(s[loop].length() == 0) {
 358                   errln("FAIL: fmt->format gave 0-length string in " + pat + " with number " + d[loop] + " in locale " + origLocale.getName());
 359                 }
 360
 361                 if(loop > 0) {
 362                     if(smatch == 0) {
 363                         UBool match = s[loop] == s[loop-1];
 364                         if(smatch == 0) {
 365                             if(match)
 366                                 smatch = loop;
 367                         }
 368                         else if( ! match)
 369                             errln("FAIL: String mismatch after match");
 370                     }
 371
 372                     if(dmatch == 0) {
 373                         // {sfb} watch out here, this might not work
 374                         UBool match = d[loop]/*.getTime()*/ == d[loop-1]/*.getTime()*/;
 375                         if(dmatch == 0) {
 376                             if(match)
 377                                 dmatch = loop;
 378                         }
 379                         else if( ! match)
 380                             errln("FAIL: Date mismatch after match");
 381                     }
 382
 383                     if(smatch != 0 && dmatch != 0)
 384                         break;
 385                 }
 386             }
 387             // At this point loop == DEPTH if we've failed, otherwise loop is the
 388             // max(smatch, dmatch), that is, the index at which we have string and
 389             // date matching.
 390
 391             // Date usually matches in 2.  Exceptions handled below.
 392             int maxDmatch = 2;
 393             int maxSmatch = 1;
 394             if (dmatch > maxDmatch) {
 395                 // Time-only pattern with zone information and a starting date in PST.
 396                 if(timeOnly && hasZoneDisplayName) {
 397                     int32_t startRaw, startDst;
 398                     fmt->getTimeZone().getOffset(d[0], FALSE, startRaw, startDst, status);
 399                     failure(status, "TimeZone::getOffset");
 400                     // if the start offset is greater than the offset on Jan 1, 1970
 401                     // in PST, then need one more round trip.  There are two cases
 402                     // fall into this category.  The start date is 1) DST or
 403                     // 2) LMT (GMT-07:52:58).
 404                     if (startRaw + startDst > -28800000) {
 405                         maxDmatch = 3;
 406                         maxSmatch = 2;
 407                     }
 408                 }
 409             }
 410
 411             // String usually matches in 1.  Exceptions are checked for here.
 412             if(smatch > maxSmatch) { // Don't compute unless necessary
 413                 UBool in0;
 414                 // Starts in BC, with no era in pattern
 415                 if( ! hasEra && getField(d[0], UCAL_ERA) == GregorianCalendar::BC)
 416                     maxSmatch = 2;
 417                 // Starts in DST, no year in pattern
 418                 else if((in0=fmt->getTimeZone().inDaylightTime(d[0], status)) && ! failure(status, "gettingDaylightTime") &&
 419                          pat.indexOf(UnicodeString("yyyy")) == -1)
 420                     maxSmatch = 2;
 421                 // If we start not in DST, but transition into DST
 422                 else if (!in0 &&
 423                          fmt->getTimeZone().inDaylightTime(d[1], status) && !failure(status, "gettingDaylightTime"))
 424                     maxSmatch = 2;
 425                 // Two digit year with no time zone change,
 426                 // unless timezone isn't used or we aren't close to the DST changover
 427                 else if (pat.indexOf(UnicodeString("y")) != -1
 428                         && pat.indexOf(UnicodeString("yyyy")) == -1
 429                         && getField(d[0], UCAL_YEAR)
 430                             != getField(d[dmatch], UCAL_YEAR)
 431                         && !failure(status, "error status [smatch>maxSmatch]")
 432                         && ((hasZoneDisplayName
 433                          && (fmt->getTimeZone().inDaylightTime(d[0], status)
 434                                 == fmt->getTimeZone().inDaylightTime(d[dmatch], status)
 435                             || getField(d[0], UCAL_MONTH) == UCAL_APRIL
 436                             || getField(d[0], UCAL_MONTH) == UCAL_OCTOBER))
 437                          || !hasZoneDisplayName)
 438                          )
 439                 {
 440                     maxSmatch = 2;
 441                 }
 442                 // If zone display name is used, fallback format might be used before 1970
 443                 else if (hasZoneDisplayName && d[0] < 0) {
 444                     maxSmatch = 2;
 445                 }
 446                 else if (timeOnly && !isGregorian && hasZoneDisplayName && maxSmatch == 1) {
 447                     int32_t startRaw, startDst;
 448                     fmt->getTimeZone().getOffset(d[1], FALSE, startRaw, startDst, status);
 449                     failure(status, "TimeZone::getOffset");
 450                     // If the calendar type is not Gregorian and the pattern is time only,
 451                     // the calendar implementation may use a date before 1970 as day 0.
 452                     // In this case, time zone offset of the default year might be
 453                     // different from the one at 1970-01-01 in PST and string match requires
 454                     // one more iteration.
 455                     if (startRaw + startDst != -28800000) {
 456                         maxSmatch = 2;
 457                     }
 458                 }
 459             }
 460
 461             /*
 462              * Special case for Japanese and Buddhist (could have large negative years)
 463              * Also, Hebrew calendar need help handling leap month.
 464              */
 465             if(dmatch > maxDmatch || smatch > maxSmatch) {
 466               const char *type = fmt->getCalendar()->getType();
 467               if(!strcmp(type,"japanese") || (!strcmp(type,"buddhist"))) {
 468                 maxSmatch = 4;
 469                 maxDmatch = 4;
 470               } else if(!strcmp(type,"hebrew")) {
 471                   maxSmatch = 3;
 472                   maxDmatch = 3;
 473                 }
 474             }
 475
 476             // Use @v to see verbose results on successful cases
 477             UBool fail = (dmatch > maxDmatch || smatch > maxSmatch);
 478             if (optionv || fail) {
 479                 if (fail) {
 480                     errln(UnicodeString("\nFAIL: Pattern: ") + pat +
 481                           " in Locale: " + origLocale.getName());
 482                 } else {
 483                     errln(UnicodeString("\nOk: Pattern: ") + pat +
 484                           " in Locale: " + origLocale.getName());
 485                 }
 486
 487                 logln("Date iters until match=%d (max allowed=%d), string iters until match=%d (max allowed=%d)",
 488                       dmatch,maxDmatch, smatch, maxSmatch);
 489
 490                 for(int j = 0; j <= loop && j < DEPTH; ++j) {
 491                     UnicodeString temp;
 492                     FieldPosition pos(FieldPosition::DONT_CARE);
 493                     errln((j>0?" P> ":"    ") + fullFormat(d[j]) + " F> " +
 494                           escape(s[j], temp) + UnicodeString(" d=") + d[j] +
 495                           (j > 0 && d[j]/*.getTime()*/==d[j-1]/*.getTime()*/?" d==":"") +
 496                           (j > 0 && s[j] == s[j-1]?" s==":""));
 497                 }
 498             }
 499             delete[] d;
 500             delete[] s;
 501         }
 502     /*}
 503     catch (ParseException e) {
 504         errln("Exception: " + e.getMessage());
 505         logln(e.toString());
 506     }*/
 507 }
 508
 509 const UnicodeString& DateFormatRoundTripTest::fullFormat(UDate d) {
 510     UErrorCode ec = U_ZERO_ERROR;
 511     if (dateFormat == 0) {
 512         dateFormat = new SimpleDateFormat((UnicodeString)"EEE MMM dd HH:mm:ss.SSS zzz yyyy G", ec);
 513         if (U_FAILURE(ec) || dateFormat == 0) {
 514             fgStr = "[FAIL: SimpleDateFormat constructor]";
 515             delete dateFormat;
 516             dateFormat = 0;
 517             return fgStr;
 518         }
 519     }
 520     fgStr.truncate(0);
 521     dateFormat->format(d, fgStr);
 522     return fgStr;
 523 }
 524
 525 /**
 526  * Return a field of the given date
 527  */
 528 int32_t DateFormatRoundTripTest::getField(UDate d, int32_t f) {
 529     // Should be synchronized, but we're single threaded so it's ok
 530     UErrorCode status = U_ZERO_ERROR;
 531     getFieldCal->setTime(d, status);
 532     failure(status, "getfieldCal->setTime");
 533     int32_t ret = getFieldCal->get((UCalendarDateFields)f, status);
 534     failure(status, "getfieldCal->get");
 535     return ret;
 536 }
 537
 538 UnicodeString& DateFormatRoundTripTest::escape(const UnicodeString& src, UnicodeString& dst )
 539 {
 540     dst.remove();
 541     for (int32_t i = 0; i < src.length(); ++i) {
 542         UChar32 c = src.char32At(i);
 543         if (c >= 0x10000) {
 544             ++i;
 545         }
 546         if (c < 0x0080) {
 547             dst += c;
 548         } else {
 549             dst += UnicodeString("[");
 550             char buf [12];
 551             sprintf(buf, "%#04x", c);
 552             dst += UnicodeString(buf);
 553             dst += UnicodeString("]");
 554         }
 555     }
 556
 557     return dst;
 558 }
 559
 560 #define U_MILLIS_PER_YEAR (365.25 * 24 * 60 * 60 * 1000)
 561
 562 UDate DateFormatRoundTripTest::generateDate(UDate minDate)
 563 {
 564   // Bring range in conformance to generateDate() below.
 565   if(minDate < (U_MILLIS_PER_YEAR * -(4000-1970))) {
 566     minDate = (U_MILLIS_PER_YEAR * -(4000-1970));
 567   }
 568   for(int i=0;i<8;i++) {
 569     double a = randFraction();
 570
 571     // Range from (min) to  (8000-1970) AD
 572     double dateRange = (0.0 - minDate) + (U_MILLIS_PER_YEAR + (8000-1970));
 573
 574     a *= dateRange;
 575
 576     // Now offset from minDate
 577     a += minDate;
 578
 579     // Last sanity check
 580     if(a>=minDate) {
 581       return a;
 582     }
 583   }
 584   return minDate;
 585 }
 586
 587 UDate DateFormatRoundTripTest::generateDate()
 588 {
 589     double a = randFraction();
 590
 591     // Now 'a' ranges from 0..1; scale it to range from 0 to 8000 years
 592     a *= 8000;
 593
 594     // Range from (4000-1970) BC to (8000-1970) AD
 595     a -= 4000;
 596
 597     // Now scale up to ms
 598     a *= 365.25 * 24 * 60 * 60 * 1000;
 599
 600     //return new Date((long)a);
 601     return a;
 602 }
 603
 604 #endif /* #if !UCONFIG_NO_FORMATTING */
 605
 606 //eof