| /* |
| ******************************************************************************* |
| * Copyright (C) 2001-2005, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| */ |
| |
| /** |
| * Port From: ICU4C v1.8.1 : format : DateFormatRoundTripTest |
| * Source File: $ICU4CRoot/source/test/intltest/dtfmtrtts.cpp |
| **/ |
| |
| package com.ibm.icu.dev.test.format; |
| |
| import com.ibm.icu.text.*; |
| import com.ibm.icu.util.*; |
| import java.util.Locale; |
| import java.util.Date; |
| import java.util.Random; |
| import java.text.FieldPosition; |
| import java.text.ParseException; |
| |
| /** |
| * Performs round-trip tests for DateFormat |
| **/ |
| public class DateFormatRoundTripTest extends com.ibm.icu.dev.test.TestFmwk { |
| public boolean INFINITE = false; |
| public boolean quick = true; |
| private SimpleDateFormat dateFormat; |
| private Calendar getFieldCal; |
| private int SPARSENESS = 18; |
| private int TRIALS = 4; |
| private int DEPTH = 5; |
| private Random ran; |
| |
| public static void main(String[] args) throws Exception { |
| new DateFormatRoundTripTest().run(args); |
| } |
| |
| public void TestDateFormatRoundTrip() { |
| dateFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss.SSS zzz yyyy G"); |
| getFieldCal = Calendar.getInstance(); |
| ran = createRandom(); // use test framework's random seed |
| |
| final Locale[] avail = DateFormat.getAvailableLocales(); |
| int locCount = avail.length; |
| logln("DateFormat available locales: " + locCount); |
| if (quick) { |
| if (locCount > 5) |
| locCount = 5; |
| logln("Quick mode: only testing first 5 Locales"); |
| } |
| TimeZone tz = TimeZone.getDefault(); |
| logln("Default TimeZone: " + tz.getID()); |
| |
| if (INFINITE) { |
| // Special infinite loop test mode for finding hard to reproduce errors |
| Locale loc = Locale.getDefault(); |
| logln("ENTERING INFINITE TEST LOOP FOR Locale: " + loc.getDisplayName()); |
| for (;;) { |
| _test(loc); |
| } |
| } else { |
| _test(Locale.getDefault()); |
| for (int i = 0; i < locCount; ++i) { |
| _test(avail[i]); |
| } |
| } |
| } |
| |
| public String styleName(int s) { |
| switch (s) { |
| case DateFormat.SHORT : |
| return "SHORT"; |
| case DateFormat.MEDIUM : |
| return "MEDIUM"; |
| case DateFormat.LONG : |
| return "LONG"; |
| case DateFormat.FULL : |
| return "FULL"; |
| default : |
| return "Unknown"; |
| } |
| } |
| |
| public void _test(Locale loc) { |
| if (!INFINITE) { |
| logln("Locale: " + loc.getDisplayName()); |
| } |
| // Total possibilities = 24 |
| // 4 date |
| // 4 time |
| // 16 date-time |
| boolean[] TEST_TABLE = new boolean[24]; |
| int i = 0; |
| for (i = 0; i < 24; ++i) |
| TEST_TABLE[i] = true; |
| |
| // If we have some sparseness, implement it here. Sparseness decreases |
| // test time by eliminating some tests, up to 23. |
| for (i = 0; i < SPARSENESS; i++) { |
| int random = (int) (ran.nextDouble() * 24); |
| if (random >= 0 && random < 24 && TEST_TABLE[i]) { |
| TEST_TABLE[random] = false; |
| } |
| } |
| |
| int itable = 0; |
| int style = 0; |
| for (style = DateFormat.FULL; style <= DateFormat.SHORT; ++style) { |
| if (TEST_TABLE[itable++]) { |
| logln("Testing style " + styleName(style)); |
| DateFormat df = DateFormat.getDateInstance(style, loc); |
| _test(df, false); |
| } |
| } |
| |
| for (style = DateFormat.FULL; style <= DateFormat.SHORT; ++style) { |
| if (TEST_TABLE[itable++]) { |
| logln("Testing style " + styleName(style)); |
| DateFormat df = DateFormat.getTimeInstance(style, loc); |
| _test(df, true); |
| } |
| } |
| |
| for (int dstyle = DateFormat.FULL; dstyle <= DateFormat.SHORT; ++dstyle) { |
| for (int tstyle = DateFormat.FULL; tstyle <= DateFormat.SHORT; ++tstyle) { |
| if (TEST_TABLE[itable++]) { |
| logln("Testing dstyle " + styleName(dstyle) + ", tstyle " + styleName(tstyle)); |
| DateFormat df = DateFormat.getDateTimeInstance(dstyle, tstyle, loc); |
| _test(df, false); |
| } |
| } |
| } |
| } |
| |
| public void _test(DateFormat fmt, boolean timeOnly) { |
| |
| if (!(fmt instanceof SimpleDateFormat)) { |
| errln("DateFormat wasn't a SimpleDateFormat"); |
| return; |
| } |
| |
| String pat = ((SimpleDateFormat) fmt).toPattern(); |
| logln(pat); |
| |
| // NOTE TO MAINTAINER |
| // This indexOf check into the pattern needs to be refined to ignore |
| // quoted characters. Currently, this isn't a problem with the locale |
| // patterns we have, but it may be a problem later. |
| |
| boolean hasEra = (pat.indexOf("G") != -1); |
| boolean hasZone = (pat.indexOf("Z") != -1) || (pat.indexOf("z") != -1); |
| |
| // Because patterns contain incomplete data representing the Date, |
| // we must be careful of how we do the roundtrip. We start with |
| // a randomly generated Date because they're easier to generate. |
| // From this we get a string. The string is our real starting point, |
| // because this string should parse the same way all the time. Note |
| // that it will not necessarily parse back to the original date because |
| // of incompleteness in patterns. For example, a time-only pattern won't |
| // parse back to the same date. |
| |
| try { |
| for (int i = 0; i < TRIALS; ++i) { |
| Date[] d = new Date[DEPTH]; |
| String[] s = new String[DEPTH]; |
| |
| d[0] = generateDate(); |
| |
| // We go through this loop until we achieve a match or until |
| // the maximum loop count is reached. We record the points at |
| // which the date and the string starts to match. Once matching |
| // starts, it should continue. |
| int loop; |
| int dmatch = 0; // d[dmatch].getTime() == d[dmatch-1].getTime() |
| int smatch = 0; // s[smatch].equals(s[smatch-1]) |
| for (loop = 0; loop < DEPTH; ++loop) { |
| if (loop > 0) { |
| d[loop] = fmt.parse(s[loop - 1]); |
| } |
| |
| s[loop] = fmt.format(d[loop]); |
| |
| if (loop > 0) { |
| if (smatch == 0) { |
| boolean match = s[loop].equals(s[loop - 1]); |
| if (smatch == 0) { |
| if (match) |
| smatch = loop; |
| } else |
| if (!match) |
| errln("FAIL: String mismatch after match"); |
| } |
| |
| if (dmatch == 0) { |
| // {sfb} watch out here, this might not work |
| boolean match = d[loop].getTime() == d[loop - 1].getTime(); |
| if (dmatch == 0) { |
| if (match) |
| dmatch = loop; |
| } else |
| if (!match) |
| errln("FAIL: Date mismatch after match"); |
| } |
| |
| if (smatch != 0 && dmatch != 0) |
| break; |
| } |
| } |
| // At this point loop == DEPTH if we've failed, otherwise loop is the |
| // max(smatch, dmatch), that is, the index at which we have string and |
| // date matching. |
| |
| // Date usually matches in 2. Exceptions handled below. |
| int maxDmatch = 2; |
| int maxSmatch = 1; |
| if (dmatch > maxDmatch || smatch > maxSmatch) { |
| //If the Date is BC |
| if (!timeOnly && !hasEra && getField(d[0], Calendar.ERA) == GregorianCalendar.BC) { |
| maxDmatch = 3; |
| maxSmatch = 2; |
| } |
| if (hasZone && (fmt.getTimeZone().inDaylightTime(d[0]) || fmt.getTimeZone().inDaylightTime(d[1]) )) { |
| maxSmatch = 2; |
| if (timeOnly) { |
| maxDmatch = 3; |
| } |
| } |
| } |
| |
| if (dmatch > maxDmatch || smatch > maxSmatch) { |
| SimpleDateFormat sdf = new SimpleDateFormat("EEEE, MMMM d, yyyy HH:mm:ss, z G", Locale.US); |
| logln("Date = " + sdf.format(d[0]) + "; ms = " + d[0].getTime()); |
| logln("Dmatch: " + dmatch + " maxD: " + maxDmatch + " Smatch:" + smatch + " maxS:" + maxSmatch); |
| errln("Pattern: " + pat + " failed to match" + "; ms = " + d[0].getTime()); |
| for (int j = 0; j <= loop && j < DEPTH; ++j) { |
| StringBuffer temp = new StringBuffer(""); |
| FieldPosition pos = new FieldPosition(0); |
| logln((j > 0 ? " P> " : " ") + dateFormat.format(d[j], temp, pos) |
| + " F> " + s[j] + (j > 0 && d[j].getTime() == d[j - 1].getTime() ? " d==" : "") |
| + (j > 0 && s[j].equals(s[j - 1]) ? " s==" : "")); |
| } |
| } |
| } |
| } catch (ParseException e) { |
| errln("Exception: " + e.getMessage()); |
| logln(e.toString()); |
| } |
| } |
| |
| public int getField(Date d, int f) { |
| getFieldCal.setTime(d); |
| int ret = getFieldCal.get(f); |
| return ret; |
| } |
| |
| public Date generateDate() { |
| double a = ran.nextDouble(); |
| // Now 'a' ranges from 0..1; scale it to range from 0 to 8000 years |
| a *= 8000; |
| // Range from (4000-1970) BC to (8000-1970) AD |
| a -= 4000; |
| // Now scale up to ms |
| a *= 365.25 * 24 * 60 * 60 * 1000; |
| return new Date((long)a); |
| } |
| } |
