/*
* 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
* @library /java/text/testlib
* @summary test Time Zone Boundary
*/
import java.text.*;
import java.util.*;
/**
* A test which discovers the boundaries of DST programmatically and verifies
* that they are correct.
*/
public class TimeZoneBoundaryTest extends IntlTest
{
static final int ONE_SECOND = 1000;
static final int ONE_MINUTE = 60*ONE_SECOND;
static final int ONE_HOUR = 60*ONE_MINUTE;
static final long ONE_DAY = 24*ONE_HOUR;
static final long ONE_YEAR = (long)(365.25 * ONE_DAY);
static final long SIX_MONTHS = ONE_YEAR / 2;
static final int MONTH_LENGTH[] = {31,29,31,30,31,30,31,31,30,31,30,31};
// These values are empirically determined to be correct
static final long PST_1997_BEG = 860320800000L;
static final long PST_1997_END = 877856400000L;
// Minimum interval for binary searches in ms; should be no larger
// than 1000.
static final long INTERVAL = 10; // Milliseconds
static final String AUSTRALIA = "Australia/Adelaide";
static final long AUSTRALIA_1997_BEG = 877797000000L;
static final long AUSTRALIA_1997_END = 859653000000L;
public static void main(String[] args) throws Exception {
new TimeZoneBoundaryTest().run(args);
}
/**
* Date.toString().substring() Boundary Test
* Look for a DST changeover to occur within 6 months of the given Date.
* The initial Date.toString() should yield a string containing the
* startMode as a SUBSTRING. The boundary will be tested to be
* at the expectedBoundary value.
*/
void findDaylightBoundaryUsingDate(Date d, String startMode, long expectedBoundary)
{
// Given a date with a year start, find the Daylight onset
// and end. The given date should be 1/1/xx in some year.
if (d.toString().indexOf(startMode) == -1)
{
logln("Error: " + startMode + " not present in " + d);
}
// Use a binary search, assuming that we have a Standard
// time at the midpoint.
long min = d.getTime();
long max = min + SIX_MONTHS;
while ((max - min) > INTERVAL)
{
long mid = (min + max) >> 1;
String s = new Date(mid).toString();
// logln(s);
if (s.indexOf(startMode) != -1)
{
min = mid;
}
else
{
max = mid;
}
}
logln("Date Before: " + showDate(min));
logln("Date After: " + showDate(max));
long mindelta = expectedBoundary - min;
long maxdelta = max - expectedBoundary;
if (mindelta >= 0 && mindelta <= INTERVAL &&
mindelta >= 0 && mindelta <= INTERVAL)
logln("PASS: Expected boundary at " + expectedBoundary);
else
errln("FAIL: Expected boundary at " + expectedBoundary);
}
void findDaylightBoundaryUsingTimeZone(Date d, boolean startsInDST, long expectedBoundary)
{
findDaylightBoundaryUsingTimeZone(d, startsInDST, expectedBoundary,
TimeZone.getDefault());
}
void findDaylightBoundaryUsingTimeZone(Date d, boolean startsInDST,
long expectedBoundary, TimeZone tz)
{
// Given a date with a year start, find the Daylight onset
// and end. The given date should be 1/1/xx in some year.
// Use a binary search, assuming that we have a Standard
// time at the midpoint.
long min = d.getTime();
long max = min + SIX_MONTHS;
if (tz.inDaylightTime(d) != startsInDST)
{
errln("FAIL: " + tz.getID() + " inDaylightTime(" +
d + ") != " + startsInDST);
startsInDST = !startsInDST; // Flip over; find the apparent value
}
if (tz.inDaylightTime(new Date(max)) == startsInDST)
{
errln("FAIL: " + tz.getID() + " inDaylightTime(" +
(new Date(max)) + ") != " + (!startsInDST));
return;
}
while ((max - min) > INTERVAL)
{
long mid = (min + max) >> 1;
boolean isIn = tz.inDaylightTime(new Date(mid));
if (isIn == startsInDST)
{
min = mid;
}
else
{
max = mid;
}
}
logln(tz.getID() + " Before: " + showDate(min, tz));
logln(tz.getID() + " After: " + showDate(max, tz));
long mindelta = expectedBoundary - min;
long maxdelta = max - expectedBoundary;
if (mindelta >= 0 && mindelta <= INTERVAL &&
mindelta >= 0 && mindelta <= INTERVAL)
logln("PASS: Expected boundary at " + expectedBoundary);
else
errln("FAIL: Expected boundary at " + expectedBoundary);
}
private static String showDate(long l)
{
return showDate(new Date(l));
}
@SuppressWarnings("deprecation")
private static String showDate(Date d)
{
return "" + d.getYear() + "/" + showNN(d.getMonth()+1) + "/" + showNN(d.getDate()) +
" " + showNN(d.getHours()) + ":" + showNN(d.getMinutes()) +
" \"" + d + "\" = " +
d.getTime();
}
private static String showDate(long l, TimeZone z)
{
return showDate(new Date(l), z);
}
@SuppressWarnings("deprecation")
private static String showDate(Date d, TimeZone zone)
{
DateFormat fmt = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
fmt.setTimeZone(zone);
return "" + d.getYear() + "/" + showNN(d.getMonth()+1) + "/" + showNN(d.getDate()) +
" " + showNN(d.getHours()) + ":" + showNN(d.getMinutes()) +
" \"" + d + "\" = " +
fmt.format(d);
}
private static String showNN(int n)
{
return ((n < 10) ? "0" : "") + n;
}
/**
* Given a date, a TimeZone, and expected values for inDaylightTime,
* useDaylightTime, zone and DST offset, verify that this is the case.
*/
void verifyDST(Date d, TimeZone time_zone,
boolean expUseDaylightTime, boolean expInDaylightTime,
int expZoneOffset, int expDSTOffset)
{
logln("-- Verifying time " + d +
" in zone " + time_zone.getID());
if (time_zone.inDaylightTime(d) == expInDaylightTime)
logln("PASS: inDaylightTime = " + time_zone.inDaylightTime(d));
else
errln("FAIL: inDaylightTime = " + time_zone.inDaylightTime(d));
if (time_zone.useDaylightTime() == expUseDaylightTime)
logln("PASS: useDaylightTime = " + time_zone.useDaylightTime());
else
errln("FAIL: useDaylightTime = " + time_zone.useDaylightTime());
if (time_zone.getRawOffset() == expZoneOffset)
logln("PASS: getRawOffset() = " + expZoneOffset/(double)ONE_HOUR);
else
errln("FAIL: getRawOffset() = " + time_zone.getRawOffset()/(double)ONE_HOUR +
"; expected " + expZoneOffset/(double)ONE_HOUR);
GregorianCalendar gc = new GregorianCalendar(time_zone);
gc.setTime(d);
int offset = time_zone.getOffset(gc.get(gc.ERA), gc.get(gc.YEAR), gc.get(gc.MONTH),
gc.get(gc.DAY_OF_MONTH), gc.get(gc.DAY_OF_WEEK),
((gc.get(gc.HOUR_OF_DAY) * 60 +
gc.get(gc.MINUTE)) * 60 +
gc.get(gc.SECOND)) * 1000 +
gc.get(gc.MILLISECOND));
if (offset == expDSTOffset)
logln("PASS: getOffset() = " + offset/(double)ONE_HOUR);
else
errln("FAIL: getOffset() = " + offset/(double)ONE_HOUR +
"; expected " + expDSTOffset/(double)ONE_HOUR);
}
@SuppressWarnings("deprecation")
public void TestBoundaries()
{
TimeZone pst = TimeZone.getTimeZone("PST");
TimeZone save = TimeZone.getDefault();
try {
TimeZone.setDefault(pst);
// DST changeover for PST is 4/6/1997 at 2 hours past midnight
Date d = new Date(97,Calendar.APRIL,6);
// i is minutes past midnight standard time
for (int i=60; i<=180; i+=15)
{
boolean inDST = (i >= 120);
Date e = new Date(d.getTime() + i*60*1000);
verifyDST(e, pst, true, inDST, -8*ONE_HOUR,
inDST ? -7*ONE_HOUR : -8*ONE_HOUR);
}
logln("========================================");
findDaylightBoundaryUsingDate(new Date(97,0,1), "PST", PST_1997_BEG);
logln("========================================");
findDaylightBoundaryUsingDate(new Date(97,6,1), "PDT", PST_1997_END);
// Southern hemisphere test
logln("========================================");
TimeZone z = TimeZone.getTimeZone(AUSTRALIA);
findDaylightBoundaryUsingTimeZone(new Date(97,0,1), true, AUSTRALIA_1997_END, z);
logln("========================================");
findDaylightBoundaryUsingTimeZone(new Date(97,0,1), false, PST_1997_BEG);
logln("========================================");
findDaylightBoundaryUsingTimeZone(new Date(97,6,1), true, PST_1997_END);
} finally {
TimeZone.setDefault(save);
}
}
void testUsingBinarySearch(SimpleTimeZone tz, Date d, long expectedBoundary)
{
// Given a date with a year start, find the Daylight onset
// and end. The given date should be 1/1/xx in some year.
// Use a binary search, assuming that we have a Standard
// time at the midpoint.
long min = d.getTime();
long max = min + (long)(365.25 / 2 * ONE_DAY);
// First check the boundaries
boolean startsInDST = tz.inDaylightTime(d);
if (tz.inDaylightTime(new Date(max)) == startsInDST)
{
logln("Error: inDaylightTime(" + (new Date(max)) + ") != " + (!startsInDST));
}
while ((max - min) > INTERVAL)
{
long mid = (min + max) >> 1;
if (tz.inDaylightTime(new Date(mid)) == startsInDST)
{
min = mid;
}
else
{
max = mid;
}
}
logln("Binary Search Before: " + showDate(min));
logln("Binary Search After: " + showDate(max));
long mindelta = expectedBoundary - min;
long maxdelta = max - expectedBoundary;
if (mindelta >= 0 && mindelta <= INTERVAL &&
mindelta >= 0 && mindelta <= INTERVAL)
logln("PASS: Expected boundary at " + expectedBoundary);
else
errln("FAIL: Expected boundary at " + expectedBoundary);
}
/*
static void testUsingMillis(Date d, boolean startsInDST)
{
long millis = d.getTime();
long max = millis + (long)(370 * ONE_DAY); // A year plus extra
boolean lastDST = startsInDST;
while (millis < max)
{
cal.setTime(new Date(millis));
boolean inDaylight = cal.inDaylightTime();
if (inDaylight != lastDST)
{
logln("Switch " + (inDaylight ? "into" : "out of")
+ " DST at " + (new Date(millis)));
lastDST = inDaylight;
}
millis += 15*ONE_MINUTE;
}
}
*/
/**
* Test new rule formats.
*/
@SuppressWarnings("deprecation")
public void TestNewRules()
{
//logln(Locale.getDefault().getDisplayName());
//logln(TimeZone.getDefault().getID());
//logln(new Date(0));
if (true)
{
// Doesn't matter what the default TimeZone is here, since we
// are creating our own TimeZone objects.
SimpleTimeZone tz;
logln("-----------------------------------------------------------------");
logln("Aug 2ndTues .. Mar 15");
tz = new SimpleTimeZone(-8*ONE_HOUR, "Test_1",
Calendar.AUGUST, 2, Calendar.TUESDAY, 2*ONE_HOUR,
Calendar.MARCH, 15, 0, 2*ONE_HOUR);
//logln(tz.toString());
logln("========================================");
testUsingBinarySearch(tz, new Date(97,0,1), 858416400000L);
logln("========================================");
testUsingBinarySearch(tz, new Date(97,6,1), 871380000000L);
logln("-----------------------------------------------------------------");
logln("Apr Wed>=14 .. Sep Sun<=20");
tz = new SimpleTimeZone(-8*ONE_HOUR, "Test_2",
Calendar.APRIL, 14, -Calendar.WEDNESDAY, 2*ONE_HOUR,
Calendar.SEPTEMBER, -20, -Calendar.SUNDAY, 2*ONE_HOUR);
//logln(tz.toString());
logln("========================================");
testUsingBinarySearch(tz, new Date(97,0,1), 861184800000L);
logln("========================================");
testUsingBinarySearch(tz, new Date(97,6,1), 874227600000L);
}
/*
if (true)
{
logln("========================================");
logln("Stepping using millis");
testUsingMillis(new Date(97,0,1), false);
}
if (true)
{
logln("========================================");
logln("Stepping using fields");
testUsingFields(1997, false);
}
if (false)
{
cal.clear();
cal.set(1997, 3, 5, 10, 0);
// cal.inDaylightTime();
logln("Date = " + cal.getTime());
logln("Millis = " + cal.getTime().getTime()/3600000);
}
*/
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// Long Bug
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//public void Test3()
//{
// findDaylightBoundaryUsingTimeZone(new Date(97,6,1), true);
//}
/**
* Find boundaries by stepping.
*/
@SuppressWarnings("deprecation")
void findBoundariesStepwise(int year, long interval, TimeZone z, int expectedChanges)
{
Date d = new Date(year - 1900, Calendar.JANUARY, 1);
long time = d.getTime(); // ms
long limit = time + ONE_YEAR + ONE_DAY;
boolean lastState = z.inDaylightTime(d);
int changes = 0;
logln("-- Zone " + z.getID() + " starts in " + year + " with DST = " + lastState);
logln("useDaylightTime = " + z.useDaylightTime());
while (time < limit)
{
d.setTime(time);
boolean state = z.inDaylightTime(d);
if (state != lastState)
{
logln((state ? "Entry " : "Exit ") +
"at " + d);
lastState = state;
++changes;
}
time += interval;
}
if (changes == 0)
{
if (!lastState && !z.useDaylightTime()) logln("No DST");
else errln("FAIL: Timezone<" + z.getID() + "> DST all year, or no DST with true useDaylightTime");
}
else if (changes != 2)
{
errln("FAIL: Timezone<" + z.getID() + "> " + changes + " changes seen; should see 0 or 2");
}
else if (!z.useDaylightTime())
{
errln("FAIL: Timezone<" + z.getID() + "> useDaylightTime false but 2 changes seen");
}
if (changes != expectedChanges)
{
errln("FAIL: Timezone<" + z.getID() + "> " + changes + " changes seen; expected " + expectedChanges);
}
}
public void TestStepwise()
{
findBoundariesStepwise(1997, ONE_DAY, TimeZone.getTimeZone("ACT"), 0);
// "EST" is disabled because its behavior depends on the mapping property. (6466476).
//findBoundariesStepwise(1997, ONE_DAY, TimeZone.getTimeZone("EST"), 2);
findBoundariesStepwise(1997, ONE_DAY, TimeZone.getTimeZone("HST"), 0);
findBoundariesStepwise(1997, ONE_DAY, TimeZone.getTimeZone("PST"), 2);
findBoundariesStepwise(1997, ONE_DAY, TimeZone.getTimeZone("PST8PDT"), 2);
findBoundariesStepwise(1997, ONE_DAY, TimeZone.getTimeZone("SystemV/PST"), 0);
findBoundariesStepwise(1997, ONE_DAY, TimeZone.getTimeZone("SystemV/PST8PDT"), 2);
findBoundariesStepwise(1997, ONE_DAY, TimeZone.getTimeZone("Japan"), 0);
findBoundariesStepwise(1997, ONE_DAY, TimeZone.getTimeZone("Europe/Paris"), 2);
findBoundariesStepwise(1997, ONE_DAY, TimeZone.getTimeZone("America/Los_Angeles"), 2);
findBoundariesStepwise(1997, ONE_DAY, TimeZone.getTimeZone(AUSTRALIA), 2);
}
}