| /* |
| * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * @test |
| * @summary test Date Format (Round Trip) |
| * @bug 8008577 |
| * @library /java/text/testlib |
| * @run main/othervm -Djava.locale.providers=COMPAT,SPI DateFormatRoundTripTest |
| */ |
| |
| import java.text.*; |
| import java.util.*; |
| |
| public class DateFormatRoundTripTest extends IntlTest { |
| |
| static Random RANDOM = null; |
| |
| static final long FIXED_SEED = 3141592653589793238L; // Arbitrary fixed value |
| |
| // Useful for turning up subtle bugs: Use -infinite and run while at lunch. |
| boolean INFINITE = false; // Warning -- makes test run infinite loop!!! |
| |
| boolean random = false; |
| |
| // Options used to reproduce failures |
| Locale locale = null; |
| String pattern = null; |
| Date initialDate = null; |
| |
| Locale[] avail; |
| TimeZone defaultZone; |
| |
| // If SPARSENESS is > 0, we don't run each exhaustive possibility. |
| // There are 24 total possible tests per each locale. A SPARSENESS |
| // of 12 means we run half of them. A SPARSENESS of 23 means we run |
| // 1 of them. SPARSENESS _must_ be in the range 0..23. |
| static final int SPARSENESS = 18; |
| |
| static final int TRIALS = 4; |
| |
| static final int DEPTH = 5; |
| |
| static SimpleDateFormat refFormat = |
| new SimpleDateFormat("EEE MMM dd HH:mm:ss.SSS zzz yyyy G"); |
| |
| public DateFormatRoundTripTest(boolean rand, long seed, boolean infinite, |
| Date date, String pat, Locale loc) { |
| random = rand; |
| if (random) { |
| RANDOM = new Random(seed); |
| } |
| INFINITE = infinite; |
| |
| initialDate = date; |
| locale = loc; |
| pattern = pat; |
| } |
| |
| /** |
| * Parse a name like "fr_FR" into new Locale("fr", "FR", ""); |
| */ |
| static Locale createLocale(String name) { |
| String country = "", |
| variant = ""; |
| int i; |
| if ((i = name.indexOf('_')) >= 0) { |
| country = name.substring(i+1); |
| name = name.substring(0, i); |
| } |
| if ((i = country.indexOf('_')) >= 0) { |
| variant = country.substring(i+1); |
| country = country.substring(0, i); |
| } |
| return new Locale(name, country, variant); |
| } |
| |
| public static void main(String[] args) throws Exception { |
| // Command-line parameters |
| Locale loc = null; |
| boolean infinite = false; |
| boolean random = false; |
| long seed = FIXED_SEED; |
| String pat = null; |
| Date date = null; |
| |
| Vector newArgs = new Vector(); |
| for (int i=0; i<args.length; ++i) { |
| if (args[i].equals("-locale") |
| && (i+1) < args.length) { |
| loc = createLocale(args[i+1]); |
| ++i; |
| } else if (args[i].equals("-date") |
| && (i+1) < args.length) { |
| date = new Date(Long.parseLong(args[i+1])); |
| ++i; |
| } else if (args[i].equals("-pattern") |
| && (i+1) < args.length) { |
| pat = args[i+1]; |
| ++i; |
| } else if (args[i].equals("-INFINITE")) { |
| infinite = true; |
| } else if (args[i].equals("-random")) { |
| random = true; |
| } else if (args[i].equals("-randomseed")) { |
| random = true; |
| seed = System.currentTimeMillis(); |
| } else if (args[i].equals("-seed") |
| && (i+1) < args.length) { |
| random = true; |
| seed = Long.parseLong(args[i+1]); |
| ++i; |
| } else { |
| newArgs.addElement(args[i]); |
| } |
| } |
| |
| if (newArgs.size() != args.length) { |
| args = new String[newArgs.size()]; |
| newArgs.copyInto(args); |
| } |
| |
| new DateFormatRoundTripTest(random, seed, infinite, date, pat, loc).run(args); |
| } |
| |
| /** |
| * Print a usage message for this test class. |
| */ |
| void usage() { |
| System.out.println(getClass().getName() + |
| ": [-pattern <pattern>] [-locale <locale>] [-date <ms>] [-INFINITE]"); |
| System.out.println(" [-random | -randomseed | -seed <seed>]"); |
| System.out.println("* Warning: Some patterns will fail with some locales."); |
| System.out.println("* Do not use -pattern unless you know what you are doing!"); |
| System.out.println("When specifying a locale, use a format such as fr_FR."); |
| System.out.println("Use -pattern, -locale, and -date to reproduce a failure."); |
| System.out.println("-random Random with fixed seed (same data every run)."); |
| System.out.println("-randomseed Random with a random seed."); |
| System.out.println("-seed <s> Random using <s> as seed."); |
| super.usage(); |
| } |
| |
| static private class TestCase { |
| private int[] date; |
| TimeZone zone; |
| FormatFactory ff; |
| boolean timeOnly; |
| private Date _date; |
| |
| TestCase(int[] d, TimeZone z, FormatFactory f, boolean timeOnly) { |
| date = d; |
| zone = z; |
| ff = f; |
| this.timeOnly = timeOnly; |
| } |
| |
| TestCase(Date d, TimeZone z, FormatFactory f, boolean timeOnly) { |
| date = null; |
| _date = d; |
| zone = z; |
| ff = f; |
| this.timeOnly = timeOnly; |
| } |
| |
| /** |
| * Create a format for testing. |
| */ |
| DateFormat createFormat() { |
| return ff.createFormat(); |
| } |
| |
| /** |
| * Return the Date of this test case; must be called with the default |
| * zone set to this TestCase's zone. |
| */ |
| Date getDate() { |
| if (_date == null) { |
| // Date constructor will work right iff we are in the target zone |
| int h = 0; |
| int m = 0; |
| int s = 0; |
| if (date.length >= 4) { |
| h = date[3]; |
| if (date.length >= 5) { |
| m = date[4]; |
| if (date.length >= 6) { |
| s = date[5]; |
| } |
| } |
| } |
| _date = new Date(date[0] - 1900, date[1] - 1, date[2], |
| h, m, s); |
| } |
| return _date; |
| } |
| |
| public String toString() { |
| return String.valueOf(getDate().getTime()) + " " + |
| refFormat.format(getDate()) + " : " + ff.createFormat().format(getDate()); |
| } |
| }; |
| |
| private interface FormatFactory { |
| DateFormat createFormat(); |
| } |
| |
| TestCase[] TESTS = { |
| // Feb 29 2004 -- ordinary leap day |
| new TestCase(new int[] {2004, 2, 29}, null, |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(DateFormat.LONG, |
| DateFormat.LONG); |
| }}, false), |
| |
| // Feb 29 2000 -- century leap day |
| new TestCase(new int[] {2000, 2, 29}, null, |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(DateFormat.LONG, |
| DateFormat.LONG); |
| }}, false), |
| |
| // 0:00:00 Jan 1 1999 -- first second of normal year |
| new TestCase(new int[] {1999, 1, 1}, null, |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(); |
| }}, false), |
| |
| // 23:59:59 Dec 31 1999 -- last second of normal year |
| new TestCase(new int[] {1999, 12, 31, 23, 59, 59}, null, |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(); |
| }}, false), |
| |
| // 0:00:00 Jan 1 2004 -- first second of leap year |
| new TestCase(new int[] {2004, 1, 1}, null, |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(); |
| }}, false), |
| |
| // 23:59:59 Dec 31 2004 -- last second of leap year |
| new TestCase(new int[] {2004, 12, 31, 23, 59, 59}, null, |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(); |
| }}, false), |
| |
| // October 25, 1998 1:59:59 AM PDT -- just before DST cessation |
| new TestCase(new Date(909305999000L), TimeZone.getTimeZone("PST"), |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(DateFormat.LONG, |
| DateFormat.LONG); |
| }}, false), |
| |
| // October 25, 1998 1:00:00 AM PST -- just after DST cessation |
| new TestCase(new Date(909306000000L), TimeZone.getTimeZone("PST"), |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(DateFormat.LONG, |
| DateFormat.LONG); |
| }}, false), |
| |
| // April 4, 1999 1:59:59 AM PST -- just before DST onset |
| new TestCase(new int[] {1999, 4, 4, 1, 59, 59}, |
| TimeZone.getTimeZone("PST"), |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(DateFormat.LONG, |
| DateFormat.LONG); |
| }}, false), |
| |
| // April 4, 1999 3:00:00 AM PDT -- just after DST onset |
| new TestCase(new Date(923220000000L), TimeZone.getTimeZone("PST"), |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(DateFormat.LONG, |
| DateFormat.LONG); |
| }}, false), |
| |
| // October 4, 1582 11:59:59 PM PDT -- just before Gregorian change |
| new TestCase(new int[] {1582, 10, 4, 23, 59, 59}, null, |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(DateFormat.LONG, |
| DateFormat.LONG); |
| }}, false), |
| |
| // October 15, 1582 12:00:00 AM PDT -- just after Gregorian change |
| new TestCase(new int[] {1582, 10, 15, 0, 0, 0}, null, |
| new FormatFactory() { public DateFormat createFormat() { |
| return DateFormat.getDateTimeInstance(DateFormat.LONG, |
| DateFormat.LONG); |
| }}, false), |
| }; |
| |
| public void TestDateFormatRoundTrip() { |
| avail = DateFormat.getAvailableLocales(); |
| logln("DateFormat available locales: " + avail.length); |
| logln("Default TimeZone: " + |
| (defaultZone = TimeZone.getDefault()).getID()); |
| |
| if (random || initialDate != null) { |
| if (RANDOM == null) { |
| // Need this for sparse coverage to reduce combinatorial explosion, |
| // even for non-random looped testing (i.e., with explicit date but |
| // not pattern or locale). |
| RANDOM = new Random(FIXED_SEED); |
| } |
| loopedTest(); |
| } else { |
| for (int i=0; i<TESTS.length; ++i) { |
| doTest(TESTS[i]); |
| } |
| } |
| } |
| |
| /** |
| * TimeZone must be set to tc.zone before this method is called. |
| */ |
| private void doTestInZone(TestCase tc) { |
| logln(escape(tc.toString())); |
| Locale save = Locale.getDefault(); |
| try { |
| if (locale != null) { |
| Locale.setDefault(locale); |
| doTest(locale, tc.createFormat(), tc.timeOnly, tc.getDate()); |
| } else { |
| for (int i=0; i<avail.length; ++i) { |
| Locale.setDefault(avail[i]); |
| doTest(avail[i], tc.createFormat(), tc.timeOnly, tc.getDate()); |
| } |
| } |
| } finally { |
| Locale.setDefault(save); |
| } |
| } |
| |
| private void doTest(TestCase tc) { |
| if (tc.zone == null) { |
| // Just run in the default zone |
| doTestInZone(tc); |
| } else { |
| try { |
| TimeZone.setDefault(tc.zone); |
| doTestInZone(tc); |
| } finally { |
| TimeZone.setDefault(defaultZone); |
| } |
| } |
| } |
| |
| private void loopedTest() { |
| if (INFINITE) { |
| // Special infinite loop test mode for finding hard to reproduce errors |
| if (locale != null) { |
| logln("ENTERING INFINITE TEST LOOP, LOCALE " + locale.getDisplayName()); |
| for (;;) doTest(locale); |
| } else { |
| logln("ENTERING INFINITE TEST LOOP, ALL LOCALES"); |
| for (;;) { |
| for (int i=0; i<avail.length; ++i) { |
| doTest(avail[i]); |
| } |
| } |
| } |
| } |
| else { |
| if (locale != null) { |
| doTest(locale); |
| } else { |
| doTest(Locale.getDefault()); |
| |
| for (int i=0; i<avail.length; ++i) { |
| doTest(avail[i]); |
| } |
| } |
| } |
| } |
| |
| void doTest(Locale loc) { |
| if (!INFINITE) logln("Locale: " + loc.getDisplayName()); |
| |
| if (pattern != null) { |
| doTest(loc, new SimpleDateFormat(pattern, loc)); |
| return; |
| } |
| |
| // Total possibilities = 24 |
| // 4 date |
| // 4 time |
| // 16 date-time |
| boolean[] TEST_TABLE = new boolean[24]; |
| for (int 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. |
| if (!INFINITE) { |
| for (int i=0; i<SPARSENESS; ) { |
| int random = (int)(java.lang.Math.random() * 24); |
| if (random >= 0 && random < 24 && TEST_TABLE[i]) { |
| TEST_TABLE[i] = false; |
| ++i; |
| } |
| } |
| } |
| |
| int itable = 0; |
| for (int style=DateFormat.FULL; style<=DateFormat.SHORT; ++style) { |
| if (TEST_TABLE[itable++]) |
| doTest(loc, DateFormat.getDateInstance(style, loc)); |
| } |
| |
| for (int style=DateFormat.FULL; style<=DateFormat.SHORT; ++style) { |
| if (TEST_TABLE[itable++]) |
| doTest(loc, DateFormat.getTimeInstance(style, loc), true); |
| } |
| |
| for (int dstyle=DateFormat.FULL; dstyle<=DateFormat.SHORT; ++dstyle) { |
| for (int tstyle=DateFormat.FULL; tstyle<=DateFormat.SHORT; ++tstyle) { |
| if (TEST_TABLE[itable++]) |
| doTest(loc, DateFormat.getDateTimeInstance(dstyle, tstyle, loc)); |
| } |
| } |
| } |
| |
| void doTest(Locale loc, DateFormat fmt) { doTest(loc, fmt, false); } |
| |
| void doTest(Locale loc, DateFormat fmt, boolean timeOnly) { |
| doTest(loc, fmt, timeOnly, initialDate != null ? initialDate : generateDate()); |
| } |
| |
| void doTest(Locale loc, DateFormat fmt, boolean timeOnly, Date date) { |
| // Skip testing with the JapaneseImperialCalendar which |
| // doesn't support the Gregorian year semantices with 'y'. |
| if (fmt.getCalendar().getClass().getName().equals("java.util.JapaneseImperialCalendar")) { |
| return; |
| } |
| |
| String pat = ((SimpleDateFormat)fmt).toPattern(); |
| String deqPat = dequotePattern(pat); // Remove quoted elements |
| |
| boolean hasEra = (deqPat.indexOf("G") != -1); |
| boolean hasZone = (deqPat.indexOf("z") != -1); |
| |
| Calendar cal = fmt.getCalendar(); |
| |
| // 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]; |
| String error = null; |
| |
| d[0] = date; |
| |
| // 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) { |
| // This should never happen; if it does, fail. |
| smatch = -1; |
| error = "FAIL: String mismatch after match"; |
| } |
| } |
| |
| if (dmatch == 0) { |
| boolean match = d[loop].getTime() == d[loop-1].getTime(); |
| if (dmatch == 0) { |
| if (match) dmatch = loop; |
| } |
| else if (!match) { |
| // This should never happen; if it does, fail. |
| dmatch = -1; |
| error = "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) { |
| // Time-only pattern with zone information and a starting date in PST. |
| if (timeOnly && hasZone && fmt.getTimeZone().inDaylightTime(d[0])) { |
| maxDmatch = 3; |
| maxSmatch = 2; |
| } |
| } |
| |
| // String usually matches in 1. Exceptions are checked for here. |
| if (smatch > maxSmatch) { // Don't compute unless necessary |
| // Starts in BC, with no era in pattern |
| if (!hasEra && getField(cal, d[0], Calendar.ERA) == GregorianCalendar.BC) |
| maxSmatch = 2; |
| // Starts in DST, no year in pattern |
| else if (fmt.getTimeZone().inDaylightTime(d[0]) && |
| deqPat.indexOf("yyyy") == -1) |
| maxSmatch = 2; |
| // Two digit year with zone and year change and zone in pattern |
| else if (hasZone && |
| fmt.getTimeZone().inDaylightTime(d[0]) != |
| fmt.getTimeZone().inDaylightTime(d[dmatch]) && |
| getField(cal, d[0], Calendar.YEAR) != |
| getField(cal, d[dmatch], Calendar.YEAR) && |
| deqPat.indexOf("y") != -1 && |
| deqPat.indexOf("yyyy") == -1) |
| maxSmatch = 2; |
| // Two digit year, year change, DST changeover hour. Example: |
| // FAIL: Pattern: dd/MM/yy HH:mm:ss |
| // Date matched in 2, wanted 2 |
| // String matched in 2, wanted 1 |
| // Thu Apr 02 02:35:52.110 PST 1795 AD F> 02/04/95 02:35:52 |
| // P> Sun Apr 02 01:35:52.000 PST 1995 AD F> 02/04/95 01:35:52 |
| // P> Sun Apr 02 01:35:52.000 PST 1995 AD F> 02/04/95 01:35:52 d== s== |
| // The problem is that the initial time is not a DST onset day, but |
| // then the year changes, and the resultant parsed time IS a DST |
| // onset day. The hour "2:XX" makes no sense if 2:00 is the DST |
| // onset, so DateFormat interprets it as 1:XX (arbitrary -- could |
| // also be 3:XX, same problem). This results in an extra iteration |
| // for String match convergence. |
| else if (!justBeforeOnset(cal, d[0]) && justBeforeOnset(cal, d[dmatch]) && |
| getField(cal, d[0], Calendar.YEAR) != |
| getField(cal, d[dmatch], Calendar.YEAR) && |
| deqPat.indexOf("y") != -1 && |
| deqPat.indexOf("yyyy") == -1) |
| maxSmatch = 2; |
| // Another spurious failure: |
| // FAIL: Pattern: dd MMMM yyyy hh:mm:ss |
| // Date matched in 2, wanted 2 |
| // String matched in 2, wanted 1 |
| // Sun Apr 05 14:28:38.410 PDT 3998 AD F> 05 April 3998 02:28:38 |
| // P> Sun Apr 05 01:28:38.000 PST 3998 AD F> 05 April 3998 01:28:38 |
| // P> Sun Apr 05 01:28:38.000 PST 3998 AD F> 05 April 3998 01:28:38 d== s== |
| // The problem here is that with an 'hh' pattern, hour from 1-12, |
| // a lack of AM/PM -- that is, no 'a' in pattern, and an initial |
| // time in the onset hour + 12:00. |
| else if (deqPat.indexOf('h') >= 0 |
| && deqPat.indexOf('a') < 0 |
| && justBeforeOnset(cal, new Date(d[0].getTime() - 12*60*60*1000L)) |
| && justBeforeOnset(cal, d[1])) |
| maxSmatch = 2; |
| } |
| |
| if (dmatch > maxDmatch || smatch > maxSmatch |
| || dmatch < 0 || smatch < 0) { |
| StringBuffer out = new StringBuffer(); |
| if (error != null) { |
| out.append(error + '\n'); |
| } |
| out.append("FAIL: Pattern: " + pat + ", Locale: " + loc + '\n'); |
| out.append(" Initial date (ms): " + d[0].getTime() + '\n'); |
| out.append(" Date matched in " + dmatch |
| + ", wanted " + maxDmatch + '\n'); |
| out.append(" String matched in " + smatch |
| + ", wanted " + maxSmatch); |
| |
| for (int j=0; j<=loop && j<DEPTH; ++j) { |
| out.append("\n " + |
| (j>0?" P> ":" ") + refFormat.format(d[j]) + " F> " + |
| escape(s[j]) + |
| (j>0&&d[j].getTime()==d[j-1].getTime()?" d==":"") + |
| (j>0&&s[j].equals(s[j-1])?" s==":"")); |
| } |
| errln(escape(out.toString())); |
| } |
| } |
| } |
| catch (ParseException e) { |
| errln(e.toString()); |
| } |
| } |
| |
| /** |
| * Return a field of the given date |
| */ |
| static int getField(Calendar cal, Date d, int f) { |
| // Should be synchronized, but we're single threaded so it's ok |
| cal.setTime(d); |
| return cal.get(f); |
| } |
| |
| /** |
| * Return true if the given Date is in the 1 hour window BEFORE the |
| * change from STD to DST for the given Calendar. |
| */ |
| static final boolean justBeforeOnset(Calendar cal, Date d) { |
| return nearOnset(cal, d, false); |
| } |
| |
| /** |
| * Return true if the given Date is in the 1 hour window AFTER the |
| * change from STD to DST for the given Calendar. |
| */ |
| static final boolean justAfterOnset(Calendar cal, Date d) { |
| return nearOnset(cal, d, true); |
| } |
| |
| /** |
| * Return true if the given Date is in the 1 hour (or whatever the |
| * DST savings is) window before or after the onset of DST. |
| */ |
| static boolean nearOnset(Calendar cal, Date d, boolean after) { |
| cal.setTime(d); |
| if ((cal.get(Calendar.DST_OFFSET) == 0) == after) { |
| return false; |
| } |
| int delta; |
| try { |
| delta = ((SimpleTimeZone) cal.getTimeZone()).getDSTSavings(); |
| } catch (ClassCastException e) { |
| delta = 60*60*1000; // One hour as ms |
| } |
| cal.setTime(new Date(d.getTime() + (after ? -delta : delta))); |
| return (cal.get(Calendar.DST_OFFSET) == 0) == after; |
| } |
| |
| static String escape(String s) { |
| StringBuffer buf = new StringBuffer(); |
| for (int i=0; i<s.length(); ++i) { |
| char c = s.charAt(i); |
| if (c < '\u0080') buf.append(c); |
| else { |
| buf.append("\\u"); |
| if (c < '\u1000') { |
| buf.append('0'); |
| if (c < '\u0100') { |
| buf.append('0'); |
| if (c < '\u0010') { |
| buf.append('0'); |
| } |
| } |
| } |
| buf.append(Integer.toHexString(c)); |
| } |
| } |
| return buf.toString(); |
| } |
| |
| /** |
| * Remove quoted elements from a pattern. E.g., change "hh:mm 'o''clock'" |
| * to "hh:mm ?". All quoted elements are replaced by one or more '?' |
| * characters. |
| */ |
| static String dequotePattern(String pat) { |
| StringBuffer out = new StringBuffer(); |
| boolean inQuote = false; |
| for (int i=0; i<pat.length(); ++i) { |
| char ch = pat.charAt(i); |
| if (ch == '\'') { |
| if ((i+1)<pat.length() |
| && pat.charAt(i+1) == '\'') { |
| // Handle "''" |
| out.append('?'); |
| ++i; |
| } else { |
| inQuote = !inQuote; |
| if (inQuote) { |
| out.append('?'); |
| } |
| } |
| } else if (!inQuote) { |
| out.append(ch); |
| } |
| } |
| return out.toString(); |
| } |
| |
| static Date generateDate() { |
| double a = (RANDOM.nextLong() & 0x7FFFFFFFFFFFFFFFL ) / |
| ((double)0x7FFFFFFFFFFFFFFFL); |
| |
| // 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); |
| } |
| } |
| |
| //eof |
