| /* |
| ******************************************************************************* |
| * Copyright (C) 2007-2008, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| */ |
| package com.ibm.icu.dev.test.timezone; |
| |
| import java.util.Date; |
| |
| import com.ibm.icu.dev.test.TestFmwk; |
| import com.ibm.icu.text.DateFormat; |
| import com.ibm.icu.util.AnnualTimeZoneRule; |
| import com.ibm.icu.util.BasicTimeZone; |
| import com.ibm.icu.util.Calendar; |
| import com.ibm.icu.util.DateTimeRule; |
| import com.ibm.icu.util.GregorianCalendar; |
| import com.ibm.icu.util.InitialTimeZoneRule; |
| import com.ibm.icu.util.RuleBasedTimeZone; |
| import com.ibm.icu.util.SimpleTimeZone; |
| import com.ibm.icu.util.TimeZone; |
| |
| /** |
| * Testing getOffset APIs using local time |
| */ |
| public class TimeZoneOffsetLocalTest extends TestFmwk { |
| |
| public static void main(String[] args) throws Exception { |
| new TimeZoneOffsetLocalTest().run(args); |
| } |
| |
| /* |
| * Testing getOffset APIs around rule transition by local standard/wall time. |
| */ |
| public void TestGetOffsetAroundTransition() { |
| final int HOUR = 60*60*1000; |
| final int MINUTE = 60*1000; |
| |
| int[][] DATES = { |
| {2006, Calendar.APRIL, 2, 1, 30, 1*HOUR+30*MINUTE}, |
| {2006, Calendar.APRIL, 2, 2, 00, 2*HOUR}, |
| {2006, Calendar.APRIL, 2, 2, 30, 2*HOUR+30*MINUTE}, |
| {2006, Calendar.APRIL, 2, 3, 00, 3*HOUR}, |
| {2006, Calendar.APRIL, 2, 3, 30, 3*HOUR+30*MINUTE}, |
| {2006, Calendar.OCTOBER, 29, 0, 30, 0*HOUR+30*MINUTE}, |
| {2006, Calendar.OCTOBER, 29, 1, 00, 1*HOUR}, |
| {2006, Calendar.OCTOBER, 29, 1, 30, 1*HOUR+30*MINUTE}, |
| {2006, Calendar.OCTOBER, 29, 2, 00, 2*HOUR}, |
| {2006, Calendar.OCTOBER, 29, 2, 30, 2*HOUR+30*MINUTE}, |
| }; |
| |
| // Expected offsets by getOffset(int era, int year, int month, int day, int dayOfWeek, int milliseconds) |
| int[] OFFSETS1 = { |
| // April 2, 2006 |
| -8*HOUR, |
| -7*HOUR, |
| -7*HOUR, |
| -7*HOUR, |
| -7*HOUR, |
| |
| // October 29, 2006 |
| -7*HOUR, |
| -8*HOUR, |
| -8*HOUR, |
| -8*HOUR, |
| -8*HOUR, |
| }; |
| |
| |
| // Expected offsets by getOffset(long time, boolean local, int[] offsets) with local = true |
| // or getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets) |
| // with nonExistingTimeOpt = LOCAL_STD/duplicatedTimeOpt = LOCAL_STD |
| int[][] OFFSETS2 = { |
| // April 2, 2006 |
| {-8*HOUR, 0}, |
| {-8*HOUR, 0}, |
| {-8*HOUR, 0}, |
| {-8*HOUR, 1*HOUR}, |
| {-8*HOUR, 1*HOUR}, |
| |
| // Oct 29, 2006 |
| {-8*HOUR, 1*HOUR}, |
| {-8*HOUR, 0}, |
| {-8*HOUR, 0}, |
| {-8*HOUR, 0}, |
| {-8*HOUR, 0}, |
| }; |
| |
| // Expected offsets by getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets) |
| // with nonExistingTimeOpt = LOCAL_DST/duplicatedTimeOpt = LOCAL_DST |
| int[][] OFFSETS3 = { |
| // April 2, 2006 |
| {-8*HOUR, 0}, |
| {-8*HOUR, 1*HOUR}, |
| {-8*HOUR, 1*HOUR}, |
| {-8*HOUR, 1*HOUR}, |
| {-8*HOUR, 1*HOUR}, |
| |
| // October 29, 2006 |
| {-8*HOUR, 1*HOUR}, |
| {-8*HOUR, 1*HOUR}, |
| {-8*HOUR, 1*HOUR}, |
| {-8*HOUR, 0}, |
| {-8*HOUR, 0}, |
| }; |
| |
| int[] offsets = new int[2]; |
| |
| TimeZone utc = TimeZone.getTimeZone("UTC"); |
| Calendar cal = Calendar.getInstance(utc); |
| cal.clear(); |
| |
| // Set up TimeZone objects - OlsonTimeZone, SimpleTimeZone and RuleBasedTimeZone |
| BasicTimeZone[] TESTZONES = new BasicTimeZone[3]; |
| |
| TESTZONES[0] = (BasicTimeZone)TimeZone.getTimeZone("America/Los_Angeles", TimeZone.TIMEZONE_ICU); |
| TESTZONES[1] = new SimpleTimeZone(-8*HOUR, "Simple Pacific Time", |
| Calendar.APRIL, 1, Calendar.SUNDAY, 2*HOUR, |
| Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*HOUR); |
| |
| InitialTimeZoneRule ir = new InitialTimeZoneRule( |
| "Pacific Standard Time", // Initial time Name |
| -8*HOUR, // Raw offset |
| 0*HOUR); // DST saving amount |
| |
| RuleBasedTimeZone rbPT = new RuleBasedTimeZone("Rule based Pacific Time", ir); |
| |
| DateTimeRule dtr; |
| AnnualTimeZoneRule atzr; |
| final int STARTYEAR = 2000; |
| |
| dtr = new DateTimeRule(Calendar.APRIL, 1, Calendar.SUNDAY, |
| 2*HOUR, DateTimeRule.WALL_TIME); // 1st Sunday in April, at 2AM wall time |
| atzr = new AnnualTimeZoneRule("Pacific Daylight Time", |
| -8*HOUR /* rawOffset */, 1*HOUR /* dstSavings */, dtr, |
| STARTYEAR, AnnualTimeZoneRule.MAX_YEAR); |
| rbPT.addTransitionRule(atzr); |
| |
| dtr = new DateTimeRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, |
| 2*HOUR, DateTimeRule.WALL_TIME); // last Sunday in October, at 2AM wall time |
| atzr = new AnnualTimeZoneRule("Pacific Standard Time", |
| -8*HOUR /* rawOffset */, 0 /* dstSavings */, dtr, |
| STARTYEAR, AnnualTimeZoneRule.MAX_YEAR); |
| rbPT.addTransitionRule(atzr); |
| |
| TESTZONES[2] = rbPT; |
| |
| // Calculate millis |
| long [] MILLIS = new long[DATES.length]; |
| for (int i = 0; i < DATES.length; i++) { |
| cal.clear(); |
| cal.set(DATES[i][0], DATES[i][1], DATES[i][2], DATES[i][3], DATES[i][4]); |
| MILLIS[i] = cal.getTimeInMillis(); |
| } |
| |
| DateFormat df = DateFormat.getInstance(); |
| df.setTimeZone(utc); |
| |
| // Test getOffset(int era, int year, int month, int day, int dayOfWeek, int millis) |
| for (int i = 0; i < TESTZONES.length; i++) { |
| for (int d = 0; d < DATES.length; d++) { |
| int offset = TESTZONES[i].getOffset(GregorianCalendar.AD, DATES[d][0], DATES[d][1], DATES[d][2], |
| Calendar.SUNDAY, DATES[d][5]); |
| if (offset != OFFSETS1[d]) { |
| errln("Bad offset returned by " + TESTZONES[i].getID() + " at " |
| + df.format(new Date(MILLIS[d])) + "(standard) - Got: " + offset + " Expected: " + OFFSETS1[d]); |
| } |
| } |
| } |
| |
| // Test getOffset(long time, boolean local, int[] offsets) with local=true |
| for (int i = 0; i < TESTZONES.length; i++) { |
| for (int m = 0; m < MILLIS.length; m++) { |
| TESTZONES[i].getOffset(MILLIS[m], true, offsets); |
| if (offsets[0] != OFFSETS2[m][0] || offsets[1] != OFFSETS2[m][1]) { |
| errln("Bad offset returned by " + TESTZONES[i].getID() + " at " |
| + df.format(new Date(MILLIS[m])) + "(wall) - Got: " |
| + offsets[0] + "/" + offsets[1] |
| + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]); |
| } |
| } |
| } |
| |
| // Test getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets) |
| // with nonExistingTimeOpt = LOCAL_STD/duplicatedTimeOpt = LOCAL_STD |
| for (int i = 0; i < TESTZONES.length; i++) { |
| for (int m = 0; m < MILLIS.length; m++) { |
| TESTZONES[i].getOffsetFromLocal(MILLIS[m], BasicTimeZone.LOCAL_STD, BasicTimeZone.LOCAL_STD, offsets); |
| if (offsets[0] != OFFSETS2[m][0] || offsets[1] != OFFSETS2[m][1]) { |
| errln("Bad offset returned by " + TESTZONES[i].getID() + " at " |
| + df.format(new Date(MILLIS[m])) + "(wall/STD/STD) - Got: " |
| + offsets[0] + "/" + offsets[1] |
| + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]); |
| } |
| } |
| } |
| |
| // Test getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets) |
| // with nonExistingTimeOpt = LOCAL_DST/duplicatedTimeOpt = LOCAL_DST |
| for (int i = 0; i < TESTZONES.length; i++) { |
| for (int m = 0; m < MILLIS.length; m++) { |
| TESTZONES[i].getOffsetFromLocal(MILLIS[m], BasicTimeZone.LOCAL_DST, BasicTimeZone.LOCAL_DST, offsets); |
| if (offsets[0] != OFFSETS3[m][0] || offsets[1] != OFFSETS3[m][1]) { |
| errln("Bad offset returned by " + TESTZONES[i].getID() + " at " |
| + df.format(new Date(MILLIS[m])) + "(wall/DST/DST) - Got: " |
| + offsets[0] + "/" + offsets[1] |
| + " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]); |
| } |
| } |
| } |
| |
| // Test getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets) |
| // with nonExistingTimeOpt = LOCAL_FORMER/duplicatedTimeOpt = LOCAL_LATTER |
| for (int i = 0; i < TESTZONES.length; i++) { |
| for (int m = 0; m < MILLIS.length; m++) { |
| TESTZONES[i].getOffsetFromLocal(MILLIS[m], BasicTimeZone.LOCAL_FORMER, BasicTimeZone.LOCAL_LATTER, offsets); |
| if (offsets[0] != OFFSETS2[m][0] || offsets[1] != OFFSETS2[m][1]) { |
| errln("Bad offset returned by " + TESTZONES[i].getID() + " at " |
| + df.format(new Date(MILLIS[m])) + "(wall/FORMER/LATTER) - Got: " |
| + offsets[0] + "/" + offsets[1] |
| + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]); |
| } |
| } |
| } |
| |
| // Test getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets) |
| // with nonExistingTimeOpt = LOCAL_LATTER/duplicatedTimeOpt = LOCAL_FORMER |
| for (int i = 0; i < TESTZONES.length; i++) { |
| for (int m = 0; m < MILLIS.length; m++) { |
| TESTZONES[i].getOffsetFromLocal(MILLIS[m], BasicTimeZone.LOCAL_LATTER, BasicTimeZone.LOCAL_FORMER, offsets); |
| if (offsets[0] != OFFSETS3[m][0] || offsets[1] != OFFSETS3[m][1]) { |
| errln("Bad offset returned by " + TESTZONES[i].getID() + " at " |
| + df.format(new Date(MILLIS[m])) + "(wall/LATTER/FORMER) - Got: " |
| + offsets[0] + "/" + offsets[1] |
| + " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]); |
| } |
| } |
| } |
| } |
| } |
