jars/icu4j-4_4_2-src/main/tests/core/src/com/ibm/icu/dev/test/timezone/TimeZoneOffsetLocalTest.java

   1 /*\r
   2  *******************************************************************************\r
   3  * Copyright (C) 2007-2008, International Business Machines Corporation and    *\r
   4  * others. All Rights Reserved.                                                *\r
   5  *******************************************************************************\r
   6  */\r
   7 package com.ibm.icu.dev.test.timezone;\r
   8 \r
   9 import java.util.Date;\r
  10 \r
  11 import com.ibm.icu.dev.test.TestFmwk;\r
  12 import com.ibm.icu.text.DateFormat;\r
  13 import com.ibm.icu.util.AnnualTimeZoneRule;\r
  14 import com.ibm.icu.util.BasicTimeZone;\r
  15 import com.ibm.icu.util.Calendar;\r
  16 import com.ibm.icu.util.DateTimeRule;\r
  17 import com.ibm.icu.util.GregorianCalendar;\r
  18 import com.ibm.icu.util.InitialTimeZoneRule;\r
  19 import com.ibm.icu.util.RuleBasedTimeZone;\r
  20 import com.ibm.icu.util.SimpleTimeZone;\r
  21 import com.ibm.icu.util.TimeZone;\r
  22 \r
  23 /**\r
  24  * Testing getOffset APIs using local time\r
  25  */\r
  26 public class TimeZoneOffsetLocalTest extends TestFmwk {\r
  27 \r
  28     public static void main(String[] args) throws Exception {\r
  29         new TimeZoneOffsetLocalTest().run(args);\r
  30     }\r
  31 \r
  32     /*\r
  33      * Testing getOffset APIs around rule transition by local standard/wall time.\r
  34      */\r
  35     public void TestGetOffsetAroundTransition() {\r
  36         final int HOUR = 60*60*1000;\r
  37         final int MINUTE = 60*1000;\r
  38 \r
  39         int[][] DATES = {\r
  40             {2006, Calendar.APRIL, 2, 1, 30, 1*HOUR+30*MINUTE},\r
  41             {2006, Calendar.APRIL, 2, 2, 00, 2*HOUR},\r
  42             {2006, Calendar.APRIL, 2, 2, 30, 2*HOUR+30*MINUTE},\r
  43             {2006, Calendar.APRIL, 2, 3, 00, 3*HOUR},\r
  44             {2006, Calendar.APRIL, 2, 3, 30, 3*HOUR+30*MINUTE},\r
  45             {2006, Calendar.OCTOBER, 29, 0, 30, 0*HOUR+30*MINUTE},\r
  46             {2006, Calendar.OCTOBER, 29, 1, 00, 1*HOUR},\r
  47             {2006, Calendar.OCTOBER, 29, 1, 30, 1*HOUR+30*MINUTE},\r
  48             {2006, Calendar.OCTOBER, 29, 2, 00, 2*HOUR},\r
  49             {2006, Calendar.OCTOBER, 29, 2, 30, 2*HOUR+30*MINUTE},\r
  50         };\r
  51 \r
  52         // Expected offsets by getOffset(int era, int year, int month, int day, int dayOfWeek, int milliseconds)\r
  53         int[] OFFSETS1 = {\r
  54             // April 2, 2006\r
  55             -8*HOUR,\r
  56             -7*HOUR,\r
  57             -7*HOUR,\r
  58             -7*HOUR,\r
  59             -7*HOUR,\r
  60 \r
  61             // October 29, 2006\r
  62             -7*HOUR,\r
  63             -8*HOUR,\r
  64             -8*HOUR,\r
  65             -8*HOUR,\r
  66             -8*HOUR,\r
  67         };\r
  68 \r
  69         \r
  70         // Expected offsets by getOffset(long time, boolean local, int[] offsets) with local = true\r
  71         // or getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets)\r
  72         // with nonExistingTimeOpt = LOCAL_STD/duplicatedTimeOpt = LOCAL_STD\r
  73         int[][] OFFSETS2 = {\r
  74             // April 2, 2006\r
  75             {-8*HOUR, 0},\r
  76             {-8*HOUR, 0},\r
  77             {-8*HOUR, 0},\r
  78             {-8*HOUR, 1*HOUR},\r
  79             {-8*HOUR, 1*HOUR},\r
  80 \r
  81             // Oct 29, 2006\r
  82             {-8*HOUR, 1*HOUR},\r
  83             {-8*HOUR, 0},\r
  84             {-8*HOUR, 0},\r
  85             {-8*HOUR, 0},\r
  86             {-8*HOUR, 0},\r
  87         };\r
  88 \r
  89         // Expected offsets by getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets)\r
  90         // with nonExistingTimeOpt = LOCAL_DST/duplicatedTimeOpt = LOCAL_DST\r
  91         int[][] OFFSETS3 = {\r
  92             // April 2, 2006\r
  93             {-8*HOUR, 0},\r
  94             {-8*HOUR, 1*HOUR},\r
  95             {-8*HOUR, 1*HOUR},\r
  96             {-8*HOUR, 1*HOUR},\r
  97             {-8*HOUR, 1*HOUR},\r
  98 \r
  99             // October 29, 2006\r
 100             {-8*HOUR, 1*HOUR},\r
 101             {-8*HOUR, 1*HOUR},\r
 102             {-8*HOUR, 1*HOUR},\r
 103             {-8*HOUR, 0},\r
 104             {-8*HOUR, 0},\r
 105         };\r
 106 \r
 107         int[] offsets = new int[2];\r
 108 \r
 109         TimeZone utc = TimeZone.getTimeZone("UTC");\r
 110         Calendar cal = Calendar.getInstance(utc);\r
 111         cal.clear();\r
 112 \r
 113         // Set up TimeZone objects - OlsonTimeZone, SimpleTimeZone and RuleBasedTimeZone\r
 114         BasicTimeZone[] TESTZONES = new BasicTimeZone[3];\r
 115 \r
 116         TESTZONES[0] = (BasicTimeZone)TimeZone.getTimeZone("America/Los_Angeles", TimeZone.TIMEZONE_ICU);\r
 117         TESTZONES[1] = new SimpleTimeZone(-8*HOUR, "Simple Pacific Time",\r
 118                                             Calendar.APRIL, 1, Calendar.SUNDAY, 2*HOUR,\r
 119                                             Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*HOUR);\r
 120 \r
 121         InitialTimeZoneRule ir = new InitialTimeZoneRule(\r
 122                 "Pacific Standard Time", // Initial time Name\r
 123                 -8*HOUR,        // Raw offset\r
 124                 0*HOUR);        // DST saving amount\r
 125 \r
 126         RuleBasedTimeZone rbPT = new RuleBasedTimeZone("Rule based Pacific Time", ir);\r
 127 \r
 128         DateTimeRule dtr;\r
 129         AnnualTimeZoneRule atzr;\r
 130         final int STARTYEAR = 2000;\r
 131 \r
 132         dtr = new DateTimeRule(Calendar.APRIL, 1, Calendar.SUNDAY,\r
 133                 2*HOUR, DateTimeRule.WALL_TIME); // 1st Sunday in April, at 2AM wall time\r
 134         atzr = new AnnualTimeZoneRule("Pacific Daylight Time",\r
 135                 -8*HOUR /* rawOffset */, 1*HOUR /* dstSavings */, dtr,\r
 136                 STARTYEAR, AnnualTimeZoneRule.MAX_YEAR);\r
 137         rbPT.addTransitionRule(atzr);\r
 138 \r
 139         dtr = new DateTimeRule(Calendar.OCTOBER, -1, Calendar.SUNDAY,\r
 140                 2*HOUR, DateTimeRule.WALL_TIME); // last Sunday in October, at 2AM wall time\r
 141         atzr = new AnnualTimeZoneRule("Pacific Standard Time",\r
 142                 -8*HOUR /* rawOffset */, 0 /* dstSavings */, dtr,\r
 143                 STARTYEAR, AnnualTimeZoneRule.MAX_YEAR);\r
 144         rbPT.addTransitionRule(atzr);\r
 145 \r
 146         TESTZONES[2] = rbPT;\r
 147 \r
 148         // Calculate millis\r
 149         long [] MILLIS = new long[DATES.length];\r
 150         for (int i = 0; i < DATES.length; i++) {\r
 151             cal.clear();\r
 152             cal.set(DATES[i][0], DATES[i][1], DATES[i][2], DATES[i][3], DATES[i][4]);\r
 153             MILLIS[i] = cal.getTimeInMillis();\r
 154         }\r
 155 \r
 156         DateFormat df = DateFormat.getInstance();\r
 157         df.setTimeZone(utc);\r
 158 \r
 159         // Test getOffset(int era, int year, int month, int day, int dayOfWeek, int millis)\r
 160         for (int i = 0; i < TESTZONES.length; i++) {\r
 161             for (int d = 0; d < DATES.length; d++) {\r
 162                 int offset = TESTZONES[i].getOffset(GregorianCalendar.AD, DATES[d][0], DATES[d][1], DATES[d][2],\r
 163                                                     Calendar.SUNDAY, DATES[d][5]);\r
 164                 if (offset != OFFSETS1[d]) {\r
 165                     errln("Bad offset returned by " + TESTZONES[i].getID() + " at "\r
 166                             + df.format(new Date(MILLIS[d])) + "(standard) - Got: " + offset + " Expected: " + OFFSETS1[d]);\r
 167                 }\r
 168             }\r
 169         }\r
 170 \r
 171         // Test getOffset(long time, boolean local, int[] offsets) with local=true\r
 172         for (int i = 0; i < TESTZONES.length; i++) {\r
 173             for (int m = 0; m < MILLIS.length; m++) {\r
 174                 TESTZONES[i].getOffset(MILLIS[m], true, offsets);\r
 175                 if (offsets[0] != OFFSETS2[m][0] || offsets[1] != OFFSETS2[m][1]) {\r
 176                     errln("Bad offset returned by " + TESTZONES[i].getID() + " at "\r
 177                             + df.format(new Date(MILLIS[m])) + "(wall) - Got: "\r
 178                             + offsets[0] + "/" + offsets[1]\r
 179                             + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);\r
 180                 }\r
 181             }\r
 182         }\r
 183 \r
 184         // Test getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets)\r
 185         // with nonExistingTimeOpt = LOCAL_STD/duplicatedTimeOpt = LOCAL_STD\r
 186         for (int i = 0; i < TESTZONES.length; i++) {\r
 187             for (int m = 0; m < MILLIS.length; m++) {\r
 188                 TESTZONES[i].getOffsetFromLocal(MILLIS[m], BasicTimeZone.LOCAL_STD, BasicTimeZone.LOCAL_STD, offsets);\r
 189                 if (offsets[0] != OFFSETS2[m][0] || offsets[1] != OFFSETS2[m][1]) {\r
 190                     errln("Bad offset returned by " + TESTZONES[i].getID() + " at "\r
 191                             + df.format(new Date(MILLIS[m])) + "(wall/STD/STD) - Got: "\r
 192                             + offsets[0] + "/" + offsets[1]\r
 193                             + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);\r
 194                 }\r
 195             }\r
 196         }\r
 197 \r
 198         // Test getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets)\r
 199         // with nonExistingTimeOpt = LOCAL_DST/duplicatedTimeOpt = LOCAL_DST\r
 200         for (int i = 0; i < TESTZONES.length; i++) {\r
 201             for (int m = 0; m < MILLIS.length; m++) {\r
 202                 TESTZONES[i].getOffsetFromLocal(MILLIS[m], BasicTimeZone.LOCAL_DST, BasicTimeZone.LOCAL_DST, offsets);\r
 203                 if (offsets[0] != OFFSETS3[m][0] || offsets[1] != OFFSETS3[m][1]) {\r
 204                     errln("Bad offset returned by " + TESTZONES[i].getID() + " at "\r
 205                             + df.format(new Date(MILLIS[m])) + "(wall/DST/DST) - Got: "\r
 206                             + offsets[0] + "/" + offsets[1]\r
 207                             + " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]);\r
 208                 }\r
 209             }\r
 210         }\r
 211 \r
 212         // Test getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets)\r
 213         // with nonExistingTimeOpt = LOCAL_FORMER/duplicatedTimeOpt = LOCAL_LATTER\r
 214         for (int i = 0; i < TESTZONES.length; i++) {\r
 215             for (int m = 0; m < MILLIS.length; m++) {\r
 216                 TESTZONES[i].getOffsetFromLocal(MILLIS[m], BasicTimeZone.LOCAL_FORMER, BasicTimeZone.LOCAL_LATTER, offsets);\r
 217                 if (offsets[0] != OFFSETS2[m][0] || offsets[1] != OFFSETS2[m][1]) {\r
 218                     errln("Bad offset returned by " + TESTZONES[i].getID() + " at "\r
 219                             + df.format(new Date(MILLIS[m])) + "(wall/FORMER/LATTER) - Got: "\r
 220                             + offsets[0] + "/" + offsets[1]\r
 221                             + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);\r
 222                 }\r
 223             }\r
 224         }\r
 225 \r
 226         // Test getOffsetFromLocal(long time, int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets)\r
 227         // with nonExistingTimeOpt = LOCAL_LATTER/duplicatedTimeOpt = LOCAL_FORMER\r
 228         for (int i = 0; i < TESTZONES.length; i++) {\r
 229             for (int m = 0; m < MILLIS.length; m++) {\r
 230                 TESTZONES[i].getOffsetFromLocal(MILLIS[m], BasicTimeZone.LOCAL_LATTER, BasicTimeZone.LOCAL_FORMER, offsets);\r
 231                 if (offsets[0] != OFFSETS3[m][0] || offsets[1] != OFFSETS3[m][1]) {\r
 232                     errln("Bad offset returned by " + TESTZONES[i].getID() + " at "\r
 233                             + df.format(new Date(MILLIS[m])) + "(wall/LATTER/FORMER) - Got: "\r
 234                             + offsets[0] + "/" + offsets[1]\r
 235                             + " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]);\r
 236                 }\r
 237             }\r
 238         }\r
 239     }\r
 240 }\r