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
DateFormatRoundTripTest()45 DateFormatRoundTripTest::DateFormatRoundTripTest() : dateFormat(nullptr) {
46 }
47
~DateFormatRoundTripTest()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
runIndexedTest(int32_t index,UBool exec,const char * & name,char * par)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
failure(UErrorCode status,const char * msg)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
failure(UErrorCode status,const char * msg,const UnicodeString & str)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
TestCentury()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
TestDateFormatRoundTrip()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
styleName(DateFormat::EStyle s)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
test(const Locale & loc)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 = static_cast<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(static_cast<DateFormat::EStyle>(style))));
240 DateFormat* df = DateFormat::createDateInstance(static_cast<DateFormat::EStyle>(style), loc);
241 if(df == nullptr) {
242 errln(UnicodeString("Could not DF::createDateInstance ") + UnicodeString(styleName(static_cast<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(static_cast<DateFormat::EStyle>(style))));
253 DateFormat* df = DateFormat::createTimeInstance(static_cast<DateFormat::EStyle>(style), loc);
254 if(df == nullptr) {
255 errln(UnicodeString("Could not DF::createTimeInstance ") + UnicodeString(styleName(static_cast<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(static_cast<DateFormat::EStyle>(dstyle))) + ", tstyle" + UnicodeString(styleName(static_cast<DateFormat::EStyle>(tstyle))));
267 DateFormat* df = DateFormat::createDateTimeInstance(static_cast<DateFormat::EStyle>(dstyle), static_cast<DateFormat::EStyle>(tstyle), loc);
268 if(df == nullptr) {
269 dataerrln(UnicodeString("Could not DF::createDateTimeInstance ") + UnicodeString(styleName(static_cast<DateFormat::EStyle>(dstyle))) + ", tstyle" + UnicodeString(styleName(static_cast<DateFormat::EStyle>(tstyle))) + "Locale: " + loc.getDisplayName(temp));
270 } else {
271 test(df, loc);
272 delete df;
273 }
274 }
275 }
276 }
277 }
278
test(DateFormat * fmt,const Locale & origLocale,UBool timeOnly)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() == nullptr) {
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 = dynamic_cast<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 } else if (timeOnly && uprv_strcmp(origLocale.getName(),"ar_JO@calendar=islamic-civil")==0 &&
474 logKnownIssue("21049", "ar_JO@calendar=islamic-civil timeOnly roundtrip converges too slowly")) {
475 // For some reason, for time-only tests, ar_JO@calendar=islamic-civil is no
476 // longer converging to a match as fast as expected above. Investigate with
477 // ICU-21022, but meanwhile allow more cycles for convergence.
478 maxSmatch = 2;
479 maxDmatch = 3;
480 }
481 }
482
483 // Use @v to see verbose results on successful cases
484 UBool fail = (dmatch > maxDmatch || smatch > maxSmatch);
485 if (optionv || fail) {
486 if (timeOnly && uprv_strcmp(origLocale.getName(),"hu_HU@calendar=islamic")==0 &&
487 logKnownIssue("ICU-21049", "hu_HU@calendar=islamic fails round trip")) {
488 continue;
489 }
490 if (fail) {
491 errln(UnicodeString("\nFAIL: Pattern: ") + pat +
492 " in Locale: " + origLocale.getName() +
493 "\nget dmatch: " + dmatch + " (expected max " + maxDmatch +
494 "), smatch: " + smatch + " (expected max " + maxSmatch + ")");
495 } else {
496 errln(UnicodeString("\nOk: Pattern: ") + pat +
497 " in Locale: " + origLocale.getName());
498 }
499
500 logln("Date iters until match=%d (max allowed=%d), string iters until match=%d (max allowed=%d)",
501 dmatch,maxDmatch, smatch, maxSmatch);
502
503 for(int j = 0; j <= loop && j < DEPTH; ++j) {
504 UnicodeString temp;
505 FieldPosition pos(FieldPosition::DONT_CARE);
506 errln((j>0?" P> ":" ") + fullFormat(d[j]) + " F> " +
507 escape(s[j], temp) + UnicodeString(" d=") + d[j] +
508 (j > 0 && d[j]/*.getTime()*/==d[j-1]/*.getTime()*/?" d==":"") +
509 (j > 0 && s[j] == s[j-1]?" s==":""));
510 }
511 }
512 delete[] d;
513 delete[] s;
514 }
515 /*}
516 catch (ParseException e) {
517 errln("Exception: " + e.getMessage());
518 logln(e.toString());
519 }*/
520 }
521
fullFormat(UDate d)522 const UnicodeString& DateFormatRoundTripTest::fullFormat(UDate d) {
523 UErrorCode ec = U_ZERO_ERROR;
524 if (dateFormat == nullptr) {
525 dateFormat = new SimpleDateFormat(UnicodeString("EEE MMM dd HH:mm:ss.SSS zzz yyyy G"), ec);
526 if (U_FAILURE(ec) || dateFormat == nullptr) {
527 fgStr = "[FAIL: SimpleDateFormat constructor]";
528 delete dateFormat;
529 dateFormat = nullptr;
530 return fgStr;
531 }
532 }
533 fgStr.truncate(0);
534 dateFormat->format(d, fgStr);
535 return fgStr;
536 }
537
538 /**
539 * Return a field of the given date
540 */
getField(UDate d,int32_t f)541 int32_t DateFormatRoundTripTest::getField(UDate d, int32_t f) {
542 // Should be synchronized, but we're single threaded so it's ok
543 UErrorCode status = U_ZERO_ERROR;
544 getFieldCal->setTime(d, status);
545 failure(status, "getfieldCal->setTime");
546 int32_t ret = getFieldCal->get(static_cast<UCalendarDateFields>(f), status);
547 failure(status, "getfieldCal->get");
548 return ret;
549 }
550
escape(const UnicodeString & src,UnicodeString & dst)551 UnicodeString& DateFormatRoundTripTest::escape(const UnicodeString& src, UnicodeString& dst )
552 {
553 dst.remove();
554 for (int32_t i = 0; i < src.length(); ++i) {
555 UChar32 c = src.char32At(i);
556 if (c >= 0x10000) {
557 ++i;
558 }
559 if (c < 0x0080) {
560 dst += c;
561 } else {
562 dst += UnicodeString("[");
563 char buf [12];
564 snprintf(buf, sizeof(buf), "%#04x", c);
565 dst += UnicodeString(buf);
566 dst += UnicodeString("]");
567 }
568 }
569
570 return dst;
571 }
572
573 #define U_MILLIS_PER_YEAR (365.25 * 24 * 60 * 60 * 1000)
574
generateDate(UDate minDate)575 UDate DateFormatRoundTripTest::generateDate(UDate minDate)
576 {
577 // Bring range in conformance to generateDate() below.
578 if(minDate < (U_MILLIS_PER_YEAR * -(4000-1970))) {
579 minDate = (U_MILLIS_PER_YEAR * -(4000-1970));
580 }
581 for(int i=0;i<8;i++) {
582 double a = randFraction();
583
584 // Range from (min) to (8000-1970) AD
585 double dateRange = (0.0 - minDate) + (U_MILLIS_PER_YEAR + (8000-1970));
586
587 a *= dateRange;
588
589 // Now offset from minDate
590 a += minDate;
591
592 // Last sanity check
593 if(a>=minDate) {
594 return a;
595 }
596 }
597 return minDate;
598 }
599
generateDate()600 UDate DateFormatRoundTripTest::generateDate()
601 {
602 double a = randFraction();
603
604 // Now 'a' ranges from 0..1; scale it to range from 0 to 8000 years
605 a *= 8000;
606
607 // Range from (4000-1970) BC to (8000-1970) AD
608 a -= 4000;
609
610 // Now scale up to ms
611 a *= 365.25 * 24 * 60 * 60 * 1000;
612
613 //return new Date((long)a);
614 return a;
615 }
616
617 #endif /* #if !UCONFIG_NO_FORMATTING */
618
619 //eof
620