jars/icu4j-4_2_1-src/src/com/ibm/icu/dev/test/timezone/TimeZoneRegression.java

   1 //##header\r
   2 /**\r
   3  *******************************************************************************\r
   4  * Copyright (C) 2000-2009, International Business Machines Corporation and    *\r
   5  * others. All Rights Reserved.                                                *\r
   6  *******************************************************************************\r
   7  */\r
   8 \r
   9 /**\r
  10  * @test 1.18 99/09/21\r
  11  * @bug 4052967 4073209 4073215 4084933 4096952 4109314 4126678 4151406 4151429\r
  12  * @bug 4154525 4154537 4154542 4154650 4159922 4162593 4173604 4176686 4184229 4208960\r
  13  */\r
  14 \r
  15 package com.ibm.icu.dev.test.timezone;\r
  16 import com.ibm.icu.util.*;\r
  17 import java.io.*;\r
  18 import com.ibm.icu.text.*;\r
  19 import com.ibm.icu.dev.test.*;\r
  20 import java.util.Date;\r
  21 import java.util.Locale;\r
  22 \r
  23 public class TimeZoneRegression extends TestFmwk {\r
  24 \r
  25     public static void main(String[] args) throws Exception {\r
  26         new TimeZoneRegression().run(args);\r
  27     }\r
  28 \r
  29     public void Test4052967() {\r
  30         logln("*** CHECK TIMEZONE AGAINST HOST OS SETTING ***");\r
  31         String id = TimeZone.getDefault().getID();\r
  32         try {\r
  33             // user.timezone is a protected system property\r
  34             logln("user.timezone: " + System.getProperty("user.timezone", "<not set>"));\r
  35             logln("TimeZone.getDefault().getID(): " + id);\r
  36             logln(new Date().toString());\r
  37             logln("*** THE RESULTS OF THIS TEST MUST BE VERIFIED MANUALLY ***");\r
  38         }\r
  39         catch (SecurityException e) {\r
  40             warnln("security exception: " + e.toString());\r
  41         }\r
  42     }\r
  43 \r
  44     public void Test4073209() {\r
  45         TimeZone z1 = TimeZone.getTimeZone("PST");\r
  46         TimeZone z2 = TimeZone.getTimeZone("PST");\r
  47         if (z1 == z2) errln("Fail: TimeZone should return clones");\r
  48     }\r
  49 \r
  50     public void Test4073215() {\r
  51         SimpleTimeZone z = new SimpleTimeZone(0, "GMT");\r
  52         if (z.useDaylightTime())\r
  53             errln("Fail: Fix test to start with non-DST zone");\r
  54         z.setStartRule(Calendar.FEBRUARY, 1, Calendar.SUNDAY, 0);\r
  55         z.setEndRule(Calendar.MARCH, -1, Calendar.SUNDAY, 0);\r
  56         if (!z.useDaylightTime())\r
  57             errln("Fail: DST not active");\r
  58         Calendar tempcal = Calendar.getInstance();\r
  59         tempcal.clear();\r
  60         tempcal.setTimeZone(z);\r
  61         tempcal.set(1997, Calendar.JANUARY, 31);\r
  62         Date d1 = tempcal.getTime();\r
  63         if (z.inDaylightTime(d1)) {\r
  64             errln("Fail: DST not working as expected");\r
  65         } \r
  66 \r
  67         tempcal.set(1997, Calendar.MARCH, 1);\r
  68         Date d2 = tempcal.getTime();\r
  69         if (!z.inDaylightTime(d2)) {\r
  70             errln("Fail: DST not working as expected");\r
  71         }\r
  72         tempcal.clear();\r
  73         tempcal.set(1997, Calendar.MARCH, 31);\r
  74         Date d3 = tempcal.getTime();\r
  75         if (z.inDaylightTime(d3)) {\r
  76             errln("Fail: DST not working as expected");\r
  77         } \r
  78     }\r
  79 \r
  80     /**\r
  81      * The expected behavior of TimeZone around the boundaries is:\r
  82      * (Assume transition time of 2:00 AM)\r
  83      *    day of onset 1:59 AM STD  = display name 1:59 AM ST\r
  84      *                 2:00 AM STD  = display name 3:00 AM DT\r
  85      *    day of end   0:59 AM STD  = display name 1:59 AM DT\r
  86      *                 1:00 AM STD  = display name 1:00 AM ST\r
  87      */\r
  88     public void Test4084933() {\r
  89         TimeZone tz = TimeZone.getTimeZone("PST");\r
  90 \r
  91         long offset1 = tz.getOffset(1,\r
  92             1997, Calendar.OCTOBER, 26, Calendar.SUNDAY, (2*60*60*1000));\r
  93         long offset2 = tz.getOffset(1,\r
  94             1997, Calendar.OCTOBER, 26, Calendar.SUNDAY, (2*60*60*1000)-1);\r
  95 \r
  96         long offset3 = tz.getOffset(1,\r
  97             1997, Calendar.OCTOBER, 26, Calendar.SUNDAY, (1*60*60*1000));\r
  98         long offset4 = tz.getOffset(1,\r
  99             1997, Calendar.OCTOBER, 26, Calendar.SUNDAY, (1*60*60*1000)-1);\r
 100 \r
 101         /*\r
 102          *  The following was added just for consistency.  It shows that going *to* Daylight\r
 103          *  Savings Time (PDT) does work at 2am.\r
 104          */\r
 105 \r
 106         long offset5 = tz.getOffset(1,\r
 107             1997, Calendar.APRIL, 6, Calendar.SUNDAY, (2*60*60*1000));\r
 108         long offset6 = tz.getOffset(1,\r
 109             1997, Calendar.APRIL, 6, Calendar.SUNDAY, (2*60*60*1000)-1);\r
 110 \r
 111         long offset7 = tz.getOffset(1,\r
 112             1997, Calendar.APRIL, 6, Calendar.SUNDAY, (1*60*60*1000));\r
 113         long offset8 = tz.getOffset(1,\r
 114             1997, Calendar.APRIL, 6, Calendar.SUNDAY, (1*60*60*1000)-1);\r
 115 \r
 116         long SToffset = -8 * 60*60*1000L;\r
 117         long DToffset = -7 * 60*60*1000L;\r
 118         if (offset1 != SToffset || offset2 != SToffset ||\r
 119             offset3 != SToffset || offset4 != DToffset ||\r
 120             offset5 != DToffset || offset6 != SToffset ||\r
 121             offset7 != SToffset || offset8 != SToffset)\r
 122             warnln("Fail: TimeZone misbehaving");\r
 123     }\r
 124 \r
 125     public void Test4096952() {\r
 126         String[] ZONES = { "GMT", "MET", "IST" };\r
 127         boolean pass = true;\r
 128         try {\r
 129             for (int i=0; i<ZONES.length; ++i) {\r
 130                 TimeZone zone = TimeZone.getTimeZone(ZONES[i]);\r
 131                 if (!zone.getID().equals(ZONES[i]))\r
 132                     warnln("Fail: Test broken; zones not instantiating");\r
 133 \r
 134                 ByteArrayOutputStream baos;\r
 135                 ObjectOutputStream ostream =\r
 136                     new ObjectOutputStream(baos = new\r
 137                                            ByteArrayOutputStream());\r
 138                 ostream.writeObject(zone);\r
 139                 ostream.close();\r
 140                 baos.close();\r
 141                 ObjectInputStream istream =\r
 142                     new ObjectInputStream(new\r
 143                                           ByteArrayInputStream(baos.toByteArray()));\r
 144                 TimeZone frankenZone = (TimeZone) istream.readObject();\r
 145                 //logln("Zone:        " + zone);\r
 146                 //logln("FrankenZone: " + frankenZone);\r
 147                 if (!zone.equals(frankenZone)) {\r
 148                     logln("TimeZone " + zone.getID() +\r
 149                           " not equal to serialized/deserialized one");\r
 150                     pass = false;\r
 151                 }\r
 152             }\r
 153             if (!pass) errln("Fail: TimeZone serialization/equality bug");\r
 154         }\r
 155         catch (IOException e) {\r
 156             errln("Fail: " + e);\r
 157             e.printStackTrace();\r
 158         }\r
 159         catch (ClassNotFoundException e) {\r
 160             errln("Fail: " + e);\r
 161             e.printStackTrace();\r
 162         }\r
 163     }\r
 164 \r
 165     public void Test4109314() {\r
 166         GregorianCalendar testCal = (GregorianCalendar)Calendar.getInstance();\r
 167         TimeZone PST = TimeZone.getTimeZone("PST");\r
 168         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 169         tempcal.clear();\r
 170         tempcal.set(1998,Calendar.APRIL,4,22,0);\r
 171         Date d1 = tempcal.getTime();\r
 172         tempcal.set(1998,Calendar.APRIL,5,6,0);\r
 173         Date d2 = tempcal.getTime();\r
 174         tempcal.set(1998,Calendar.OCTOBER,24,22,0);\r
 175         Date d3 = tempcal.getTime();\r
 176         tempcal.set(1998,Calendar.OCTOBER,25,6,0);\r
 177         Date d4 = tempcal.getTime();\r
 178         Object[] testData = {\r
 179             PST, d1, d2,\r
 180             PST, d3, d4,\r
 181         };\r
 182         boolean pass=true;\r
 183         for (int i=0; i<testData.length; i+=3) {\r
 184             testCal.setTimeZone((TimeZone) testData[i]);\r
 185             long t = ((Date)testData[i+1]).getTime();\r
 186             Date end = (Date) testData[i+2];\r
 187             while (t < end.getTime()) {\r
 188                 testCal.setTime(new Date(t));\r
 189                 if (!checkCalendar314(testCal, (TimeZone) testData[i]))\r
 190                     pass = false;\r
 191                 t += 60*60*1000L;\r
 192             }\r
 193         }\r
 194         if (!pass) errln("Fail: TZ API inconsistent");\r
 195     }\r
 196 \r
 197     boolean checkCalendar314(GregorianCalendar testCal, TimeZone testTZ) {\r
 198         // GregorianCalendar testCal = (GregorianCalendar)aCal.clone();\r
 199 \r
 200         final int ONE_DAY = 24*60*60*1000;\r
 201 \r
 202         int tzOffset, tzRawOffset;\r
 203         Float tzOffsetFloat,tzRawOffsetFloat;\r
 204         // Here is where the user made an error.  They were passing in the value of\r
 205         // the MILLSECOND field; you need to pass in the millis in the day in STANDARD\r
 206         // time.\r
 207         int millis = testCal.get(Calendar.MILLISECOND) +\r
 208             1000 * (testCal.get(Calendar.SECOND) +\r
 209                     60 * (testCal.get(Calendar.MINUTE) +\r
 210                           60 * (testCal.get(Calendar.HOUR_OF_DAY)))) -\r
 211             testCal.get(Calendar.DST_OFFSET);\r
 212 \r
 213         /* Fix up millis to be in range.  ASSUME THAT WE ARE NOT AT THE\r
 214          * BEGINNING OR END OF A MONTH.  We must add this code because\r
 215          * getOffset() has been changed to be more strict about the parameters\r
 216          * it receives -- it turns out that this test was passing in illegal\r
 217          * values. */\r
 218         int date = testCal.get(Calendar.DATE);\r
 219         int dow  = testCal.get(Calendar.DAY_OF_WEEK);\r
 220         while (millis < 0) {\r
 221             millis += ONE_DAY;\r
 222             --date;\r
 223             dow = Calendar.SUNDAY + ((dow - Calendar.SUNDAY + 6) % 7);\r
 224         }\r
 225         while (millis >= ONE_DAY) {\r
 226             millis -= ONE_DAY;\r
 227             ++date;\r
 228             dow = Calendar.SUNDAY + ((dow - Calendar.SUNDAY + 1) % 7);\r
 229         }\r
 230 \r
 231         tzOffset = testTZ.getOffset(testCal.get(Calendar.ERA),\r
 232                                     testCal.get(Calendar.YEAR),\r
 233                                     testCal.get(Calendar.MONTH),\r
 234                                     date,\r
 235                                     dow,\r
 236                                     millis);\r
 237         tzRawOffset = testTZ.getRawOffset();\r
 238         tzOffsetFloat = new Float((float)tzOffset/(float)3600000);\r
 239         tzRawOffsetFloat = new Float((float)tzRawOffset/(float)3600000);\r
 240 \r
 241         Date testDate = testCal.getTime();\r
 242 \r
 243         boolean inDaylightTime = testTZ.inDaylightTime(testDate);\r
 244         SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy HH:mm");\r
 245         sdf.setCalendar(testCal);\r
 246         String inDaylightTimeString;\r
 247 \r
 248         boolean passed;\r
 249 \r
 250         if (inDaylightTime)\r
 251         {\r
 252             inDaylightTimeString = " DST ";\r
 253             passed = (tzOffset == (tzRawOffset + 3600000));\r
 254         }\r
 255         else\r
 256         {\r
 257             inDaylightTimeString = "     ";\r
 258             passed = (tzOffset == tzRawOffset);\r
 259         }\r
 260 \r
 261         String output = testTZ.getID() + " " + sdf.format(testDate) +\r
 262             " Offset(" + tzOffsetFloat + ")" +\r
 263             " RawOffset(" + tzRawOffsetFloat + ")" +\r
 264             " " + millis/(float)3600000 + " " +\r
 265             inDaylightTimeString;\r
 266 \r
 267         if (passed)\r
 268             output += "     ";\r
 269         else\r
 270             output += "ERROR";\r
 271 \r
 272         if (passed) logln(output); else errln(output);\r
 273         return passed;\r
 274     }\r
 275 \r
 276     /**\r
 277      * CANNOT REPRODUDE\r
 278      *\r
 279      * Yet another _alleged_ bug in TimeZone.getOffset(), a method that never\r
 280      * should have been made public.  It's simply too hard to use correctly.\r
 281      *\r
 282      * The original test code failed to do the following:\r
 283      * (1) Call Calendar.setTime() before getting the fields!\r
 284      * (2) Use the right millis (as usual) for getOffset(); they were passing\r
 285      *     in the MILLIS field, instead of the STANDARD MILLIS IN DAY.\r
 286      * When you fix these two problems, the test passes, as expected.\r
 287      */\r
 288     public void Test4126678() {\r
 289     // Note: this test depends on the PST time zone.\r
 290     TimeZone initialZone = TimeZone.getDefault();\r
 291         Calendar cal = Calendar.getInstance();\r
 292         TimeZone tz = TimeZone.getTimeZone("PST");\r
 293     TimeZone.setDefault(tz);\r
 294         cal.setTimeZone(tz);\r
 295 \r
 296         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 297         tempcal.clear();\r
 298         tempcal.set(1998, Calendar.APRIL, 5, 10, 0);\r
 299         Date dt = tempcal.getTime();\r
 300     // the dt value is local time in PST.\r
 301         if (!tz.inDaylightTime(dt))\r
 302             errln("We're not in Daylight Savings Time and we should be.\n");\r
 303 \r
 304         cal.setTime(dt);\r
 305         int era = cal.get(Calendar.ERA);\r
 306         int year = cal.get(Calendar.YEAR);\r
 307         int month = cal.get(Calendar.MONTH);\r
 308         int day = cal.get(Calendar.DATE);\r
 309         int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);\r
 310         int millis = cal.get(Calendar.MILLISECOND) +\r
 311             (cal.get(Calendar.SECOND) +\r
 312              (cal.get(Calendar.MINUTE) +\r
 313               (cal.get(Calendar.HOUR) * 60) * 60) * 1000) -\r
 314             cal.get(Calendar.DST_OFFSET);\r
 315 \r
 316         long offset = tz.getOffset(era, year, month, day, dayOfWeek, millis);\r
 317         long raw_offset = tz.getRawOffset();\r
 318         if (offset == raw_offset)\r
 319             errln("Offsets should not match when in DST");\r
 320 \r
 321     // restore the initial time zone so that this test case\r
 322     // doesn't affect the others.\r
 323     TimeZone.setDefault(initialZone);\r
 324     }\r
 325 \r
 326     /**\r
 327      * TimeZone.getAvailableIDs(int) throws exception for certain values,\r
 328      * due to a faulty constant in TimeZone.java.\r
 329      */\r
 330     public void Test4151406() {\r
 331         int max = 0;\r
 332         for (int h=-28; h<=30; ++h) {\r
 333             // h is in half-hours from GMT; rawoffset is in millis\r
 334             int rawoffset = h * 1800000;\r
 335             int hh = (h<0) ? -h : h;\r
 336             String hname = ((h<0) ? "GMT-" : "GMT+") +\r
 337                 ((hh/2 < 10) ? "0" : "") +\r
 338                 (hh/2) + ':' +\r
 339                 ((hh%2==0) ? "00" : "30");\r
 340             try {\r
 341                 String[] ids = TimeZone.getAvailableIDs(rawoffset);\r
 342                 if (ids.length > max) max = ids.length;\r
 343                 logln(hname + ' ' + ids.length +\r
 344                       ((ids.length > 0) ? (" e.g. " + ids[0]) : ""));\r
 345             } catch (Exception e) {\r
 346                 errln(hname + ' ' + "Fail: " + e);\r
 347             }\r
 348         }\r
 349         logln("Maximum zones per offset = " + max);\r
 350     }\r
 351 \r
 352     public void Test4151429() {\r
 353         try {\r
 354             TimeZone tz = TimeZone.getTimeZone("GMT");\r
 355             /*String name =*/ tz.getDisplayName(true, Integer.MAX_VALUE,\r
 356                                             Locale.getDefault());\r
 357             errln("IllegalArgumentException not thrown by TimeZone.getDisplayName()");\r
 358         } catch(IllegalArgumentException e) {\r
 359             System.out.print("");\r
 360         }\r
 361     }\r
 362 \r
 363     /**\r
 364      * SimpleTimeZone accepts illegal DST savings values.  These values\r
 365      * must be non-zero.  There is no upper limit at this time.\r
 366      */\r
 367     public void Test4154525() {\r
 368         final int GOOD = 1, BAD = 0;\r
 369         int[] DATA = {\r
 370             1, GOOD,\r
 371             0, BAD,\r
 372             -1, BAD,\r
 373             60*60*1000, GOOD,\r
 374             Integer.MIN_VALUE, BAD,\r
 375             // Integer.MAX_VALUE, ?, // no upper limit on DST savings at this time\r
 376         };\r
 377         for (int i=0; i<DATA.length; i+=2) {\r
 378             int savings = DATA[i];\r
 379             boolean valid = DATA[i+1] == GOOD;\r
 380             String method = null;\r
 381             for (int j=0; j<2; ++j) {\r
 382                 try {\r
 383                     switch (j) {\r
 384                     case 0:\r
 385                         method = "constructor";\r
 386                         SimpleTimeZone z = new SimpleTimeZone(0, "id",\r
 387                             Calendar.JANUARY, 1, 0, 0,\r
 388                             Calendar.MARCH, 1, 0, 0,\r
 389                             savings); // <- what we're interested in\r
 390                         break;\r
 391                     case 1:\r
 392                         method = "setDSTSavings()";\r
 393                         z = new SimpleTimeZone(0, "GMT");\r
 394                         z.setDSTSavings(savings);\r
 395                         break;\r
 396                     }\r
 397                     if (valid) {\r
 398                         logln("Pass: DST savings of " + savings + " accepted by " + method);\r
 399                     } else {\r
 400                         errln("Fail: DST savings of " + savings + " accepted by " + method);\r
 401                     }\r
 402                 } catch (IllegalArgumentException e) {\r
 403                     if (valid) {\r
 404                         errln("Fail: DST savings of " + savings + " to " + method + " gave " + e);\r
 405                     } else {\r
 406                         logln("Pass: DST savings of " + savings + " to " + method + " gave " + e);\r
 407                     }\r
 408                 }\r
 409             }\r
 410         }\r
 411     }\r
 412 \r
 413     /**\r
 414      * SimpleTimeZone.hasSameRules() doesn't work for zones with no DST\r
 415      * and different DST parameters.\r
 416      */\r
 417     public void Test4154537() {\r
 418         // tz1 and tz2 have no DST and different rule parameters\r
 419         SimpleTimeZone tz1 = new SimpleTimeZone(0, "1", 0, 0, 0, 0, 2, 0, 0, 0);\r
 420         SimpleTimeZone tz2 = new SimpleTimeZone(0, "2", 1, 0, 0, 0, 3, 0, 0, 0);\r
 421         // tza and tzA have the same rule params\r
 422         SimpleTimeZone tza = new SimpleTimeZone(0, "a", 0, 1, 0, 0, 3, 2, 0, 0);\r
 423         SimpleTimeZone tzA = new SimpleTimeZone(0, "A", 0, 1, 0, 0, 3, 2, 0, 0);\r
 424         // tzb differs from tza\r
 425         SimpleTimeZone tzb = new SimpleTimeZone(0, "b", 0, 1, 0, 0, 3, 1, 0, 0);\r
 426         if (tz1.useDaylightTime() || tz2.useDaylightTime() ||\r
 427             !tza.useDaylightTime() || !tzA.useDaylightTime() ||\r
 428             !tzb.useDaylightTime()) {\r
 429             errln("Test is broken -- rewrite it");\r
 430         }\r
 431         if (!tza.hasSameRules(tzA) || tza.hasSameRules(tzb)) {\r
 432             errln("Fail: hasSameRules() broken for zones with rules");\r
 433         }\r
 434         if (!tz1.hasSameRules(tz2)) {\r
 435             errln("Fail: hasSameRules() returns false for zones without rules");\r
 436             errln("zone 1 = " + tz1);\r
 437             errln("zone 2 = " + tz2);\r
 438         }\r
 439     }\r
 440 \r
 441     /**\r
 442      * SimpleTimeZone constructors, setStartRule(), and setEndRule() don't\r
 443      * check for out-of-range arguments.\r
 444      */\r
 445     public void Test4154542() {\r
 446         final int GOOD = 1;\r
 447         final int BAD  = 0;\r
 448 \r
 449         final int GOOD_MONTH       = Calendar.JANUARY;\r
 450         final int GOOD_DAY         = 1;\r
 451         final int GOOD_DAY_OF_WEEK = Calendar.SUNDAY;\r
 452         final int GOOD_TIME        = 0;\r
 453 \r
 454         int[] DATA = {\r
 455             GOOD, Integer.MIN_VALUE,    0,  Integer.MAX_VALUE,   Integer.MIN_VALUE,\r
 456             GOOD, Calendar.JANUARY,    -5,  Calendar.SUNDAY,     0,\r
 457             GOOD, Calendar.DECEMBER,    5,  Calendar.SATURDAY,   24*60*60*1000-1,\r
 458             BAD,  Calendar.DECEMBER,    5,  Calendar.SATURDAY,   24*60*60*1000+1,\r
 459             BAD,  Calendar.DECEMBER,    5,  Calendar.SATURDAY,  -1,\r
 460             BAD,  Calendar.JANUARY,    -6,  Calendar.SUNDAY,     0,\r
 461             BAD,  Calendar.DECEMBER,    6,  Calendar.SATURDAY,   24*60*60*1000,\r
 462             GOOD, Calendar.DECEMBER,    1,  0,                   0,\r
 463             GOOD, Calendar.DECEMBER,   31,  0,                   0,\r
 464             BAD,  Calendar.APRIL,      31,  0,                   0,\r
 465             BAD,  Calendar.DECEMBER,   32,  0,                   0,\r
 466             BAD,  Calendar.JANUARY-1,   1,  Calendar.SUNDAY,     0,\r
 467             BAD,  Calendar.DECEMBER+1,  1,  Calendar.SUNDAY,     0,\r
 468             GOOD, Calendar.DECEMBER,   31, -Calendar.SUNDAY,     0,\r
 469             GOOD, Calendar.DECEMBER,   31, -Calendar.SATURDAY,   0,\r
 470             BAD,  Calendar.DECEMBER,   32, -Calendar.SATURDAY,   0,\r
 471             BAD,  Calendar.DECEMBER,  -32, -Calendar.SATURDAY,   0,\r
 472             BAD,  Calendar.DECEMBER,   31, -Calendar.SATURDAY-1, 0,\r
 473         };\r
 474         SimpleTimeZone zone = new SimpleTimeZone(0, "Z");\r
 475         for (int i=0; i<DATA.length; i+=5) {\r
 476             boolean shouldBeGood = (DATA[i] == GOOD);\r
 477             int month     = DATA[i+1];\r
 478             int day       = DATA[i+2];\r
 479             int dayOfWeek = DATA[i+3];\r
 480             int time      = DATA[i+4];\r
 481 \r
 482             Exception ex = null;\r
 483             try {\r
 484                 zone.setStartRule(month, day, dayOfWeek, time);\r
 485             } catch (IllegalArgumentException e) {\r
 486                 ex = e;\r
 487             }\r
 488             if ((ex == null) != shouldBeGood) {\r
 489                 errln("setStartRule(month=" + month + ", day=" + day +\r
 490                       ", dayOfWeek=" + dayOfWeek + ", time=" + time +\r
 491                       (shouldBeGood ? (") should work but throws " + ex)\r
 492                        : ") should fail but doesn't"));\r
 493             }\r
 494 \r
 495             ex = null;\r
 496             try {\r
 497                 zone.setEndRule(month, day, dayOfWeek, time);\r
 498             } catch (IllegalArgumentException e) {\r
 499                 ex = e;\r
 500             }\r
 501             if ((ex == null) != shouldBeGood) {\r
 502                 errln("setEndRule(month=" + month + ", day=" + day +\r
 503                       ", dayOfWeek=" + dayOfWeek + ", time=" + time +\r
 504                       (shouldBeGood ? (") should work but throws " + ex)\r
 505                        : ") should fail but doesn't"));\r
 506             }\r
 507 \r
 508             ex = null;\r
 509             try {\r
 510                 /*SimpleTimeZone temp =*/ new SimpleTimeZone(0, "Z",\r
 511                         month, day, dayOfWeek, time,\r
 512                         GOOD_MONTH, GOOD_DAY, GOOD_DAY_OF_WEEK, GOOD_TIME);\r
 513             } catch (IllegalArgumentException e) {\r
 514                 ex = e;\r
 515             }\r
 516             if ((ex == null) != shouldBeGood) {\r
 517                 errln("SimpleTimeZone(month=" + month + ", day=" + day +\r
 518                       ", dayOfWeek=" + dayOfWeek + ", time=" + time +\r
 519                       (shouldBeGood ? (", <end>) should work but throws " + ex)\r
 520                        : ", <end>) should fail but doesn't"));\r
 521             }\r
 522 \r
 523             ex = null;\r
 524             try {\r
 525                 /*SimpleTimeZone temp = */new SimpleTimeZone(0, "Z",\r
 526                         GOOD_MONTH, GOOD_DAY, GOOD_DAY_OF_WEEK, GOOD_TIME,\r
 527                         month, day, dayOfWeek, time);\r
 528                // temp = null;\r
 529             } catch (IllegalArgumentException e) {\r
 530                 ex = e;\r
 531             }\r
 532             if ((ex == null) != shouldBeGood) {\r
 533                 errln("SimpleTimeZone(<start>, month=" + month + ", day=" + day +\r
 534                       ", dayOfWeek=" + dayOfWeek + ", time=" + time +\r
 535                       (shouldBeGood ? (") should work but throws " + ex)\r
 536                        : ") should fail but doesn't"));\r
 537             }\r
 538         }\r
 539     }\r
 540 \r
 541     /**\r
 542      * SimpleTimeZone.getOffset accepts illegal arguments.\r
 543      */\r
 544     public void Test4154650() {\r
 545         final int GOOD=1, BAD=0;\r
 546         final int GOOD_ERA=GregorianCalendar.AD, GOOD_YEAR=1998, GOOD_MONTH=Calendar.AUGUST;\r
 547         final int GOOD_DAY=2, GOOD_DOW=Calendar.SUNDAY, GOOD_TIME=16*3600000;\r
 548         int[] DATA = {\r
 549             GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME,\r
 550 \r
 551             GOOD, GregorianCalendar.BC, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME,\r
 552             GOOD, GregorianCalendar.AD, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME,\r
 553             BAD,  GregorianCalendar.BC-1, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME,\r
 554             BAD,  GregorianCalendar.AD+1, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME,\r
 555 \r
 556             GOOD, GOOD_ERA, GOOD_YEAR, Calendar.JANUARY, GOOD_DAY, GOOD_DOW, GOOD_TIME,\r
 557             GOOD, GOOD_ERA, GOOD_YEAR, Calendar.DECEMBER, GOOD_DAY, GOOD_DOW, GOOD_TIME,\r
 558             BAD,  GOOD_ERA, GOOD_YEAR, Calendar.JANUARY-1, GOOD_DAY, GOOD_DOW, GOOD_TIME,\r
 559             BAD,  GOOD_ERA, GOOD_YEAR, Calendar.DECEMBER+1, GOOD_DAY, GOOD_DOW, GOOD_TIME,\r
 560 \r
 561             GOOD, GOOD_ERA, GOOD_YEAR, Calendar.JANUARY, 1, GOOD_DOW, GOOD_TIME,\r
 562             GOOD, GOOD_ERA, GOOD_YEAR, Calendar.JANUARY, 31, GOOD_DOW, GOOD_TIME,\r
 563             BAD,  GOOD_ERA, GOOD_YEAR, Calendar.JANUARY, 0, GOOD_DOW, GOOD_TIME,\r
 564             BAD,  GOOD_ERA, GOOD_YEAR, Calendar.JANUARY, 32, GOOD_DOW, GOOD_TIME,\r
 565 \r
 566             GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, Calendar.SUNDAY, GOOD_TIME,\r
 567             GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, Calendar.SATURDAY, GOOD_TIME,\r
 568             BAD,  GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, Calendar.SUNDAY-1, GOOD_TIME,\r
 569             BAD,  GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, Calendar.SATURDAY+1, GOOD_TIME,\r
 570 \r
 571             GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, 0,\r
 572             GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, 24*3600000-1,\r
 573             BAD,  GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, -1,\r
 574             BAD,  GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, 24*3600000,\r
 575         };\r
 576 \r
 577         TimeZone tz = TimeZone.getDefault();\r
 578         for (int i=0; i<DATA.length; i+=7) {\r
 579             boolean good = DATA[i] == GOOD;\r
 580             IllegalArgumentException e = null;\r
 581             try {\r
 582                 /*int offset =*/ tz.getOffset(DATA[i+1], DATA[i+2], DATA[i+3],\r
 583                                           DATA[i+4], DATA[i+5], DATA[i+6]);\r
 584                 //offset = 0;\r
 585            } catch (IllegalArgumentException ex) {\r
 586                 e = ex;\r
 587             }\r
 588             if (good != (e == null)) {\r
 589                 errln("Fail: getOffset(" +\r
 590                       DATA[i+1] + ", " + DATA[i+2] + ", " + DATA[i+3] + ", " +\r
 591                       DATA[i+4] + ", " + DATA[i+5] + ", " + DATA[i+6] +\r
 592                       (good ? (") threw " + e) : ") accepts invalid args"));\r
 593             }\r
 594         }\r
 595     }\r
 596 \r
 597     /**\r
 598      * TimeZone constructors allow null IDs.\r
 599      */\r
 600     public void Test4159922() {\r
 601         TimeZone z = null;\r
 602 \r
 603         // TimeZone API.  Only hasSameRules() and setDefault() should\r
 604         // allow null.\r
 605         try {\r
 606             z = TimeZone.getTimeZone(null);\r
 607             errln("FAIL: Null allowed in getTimeZone");\r
 608         } catch (NullPointerException e) {\r
 609             System.out.print("");\r
 610         }\r
 611         z = TimeZone.getTimeZone("GMT");\r
 612         try {\r
 613         // {dlf} requiring cast for disambiguation is ok for compatibility since null\r
 614         // is not a valid argument to this API\r
 615             z.getDisplayName(false, TimeZone.SHORT, (ULocale)null);\r
 616             errln("FAIL: Null allowed in getDisplayName(3)");\r
 617         } catch (NullPointerException e) {\r
 618             System.out.print("");\r
 619         }\r
 620         try {\r
 621         // {dlf} see above\r
 622             z.getDisplayName((ULocale)null);\r
 623             errln("FAIL: Null allowed in getDisplayName(1)");\r
 624         } catch (NullPointerException e) {\r
 625             System.out.print("");\r
 626         }\r
 627         try {\r
 628             if (z.hasSameRules(null)) {\r
 629                 errln("FAIL: hasSameRules returned true");\r
 630             }\r
 631         } catch (NullPointerException e) {\r
 632             errln("FAIL: Null NOT allowed in hasSameRules");\r
 633         }\r
 634         try {\r
 635             z.inDaylightTime(null);\r
 636             errln("FAIL: Null allowed in inDaylightTime");\r
 637         } catch (NullPointerException e) {\r
 638             System.out.print("");\r
 639         }\r
 640         try {\r
 641             z.setID(null);\r
 642             errln("FAIL: Null allowed in setID");\r
 643         } catch (NullPointerException e) {\r
 644             System.out.print("");\r
 645         }\r
 646 \r
 647         TimeZone save = TimeZone.getDefault();\r
 648         try {\r
 649             TimeZone.setDefault(null);\r
 650         } catch (NullPointerException e) {\r
 651             errln("FAIL: Null NOT allowed in setDefault");\r
 652         } finally {\r
 653             TimeZone.setDefault(save);\r
 654         }\r
 655 \r
 656         // SimpleTimeZone API\r
 657         SimpleTimeZone s = null;\r
 658         try {\r
 659             s = new SimpleTimeZone(0, null);\r
 660             errln("FAIL: Null allowed in SimpleTimeZone(2)");\r
 661         } catch (NullPointerException e) {\r
 662             System.out.print("");\r
 663         }\r
 664         try {\r
 665             s = new SimpleTimeZone(0, null, 0, 1, 0, 0, 0, 1, 0, 0);\r
 666             errln("FAIL: Null allowed in SimpleTimeZone(10)");\r
 667         } catch (NullPointerException e) {\r
 668             System.out.print("");\r
 669         }\r
 670         try {\r
 671             s = new SimpleTimeZone(0, null, 0, 1, 0, 0, 0, 1, 0, 0, 1000);\r
 672             errln("FAIL: Null allowed in SimpleTimeZone(11)");\r
 673         } catch (NullPointerException e) {\r
 674             System.out.print("");\r
 675         }\r
 676         if(s!=null){\r
 677             errln("FAIL: Did not get the expected Exception");\r
 678         }\r
 679     }\r
 680 \r
 681     /**\r
 682      * TimeZone broken at midnight.  The TimeZone code fails to handle\r
 683      * transitions at midnight correctly.\r
 684      */\r
 685     public void Test4162593() {\r
 686         SimpleDateFormat fmt = new SimpleDateFormat("z", Locale.US);\r
 687         final int ONE_HOUR = 60*60*1000;\r
 688         final float H = (float) ONE_HOUR;\r
 689         TimeZone initialZone = TimeZone.getDefault();\r
 690         SimpleDateFormat sdf = new SimpleDateFormat("MMM dd yyyy HH:mm z");\r
 691 \r
 692         SimpleTimeZone asuncion = new SimpleTimeZone(-4*ONE_HOUR, "America/Asuncion" /*PY%sT*/,\r
 693             Calendar.OCTOBER, 1, 0 /*DOM*/, 0*ONE_HOUR,\r
 694             Calendar.MARCH, 1, 0 /*DOM*/, 0*ONE_HOUR, 1*ONE_HOUR);\r
 695 \r
 696         /* Zone\r
 697          * Starting time\r
 698          * Transition expected between start+1H and start+2H\r
 699          */\r
 700         Object[] DATA = {\r
 701             new SimpleTimeZone(2*ONE_HOUR, "Asia/Damascus" /*EE%sT*/,\r
 702                 Calendar.APRIL, 1, 0 /*DOM*/, 0*ONE_HOUR,\r
 703                 Calendar.OCTOBER, 1, 0 /*DOM*/, 0*ONE_HOUR, 1*ONE_HOUR),\r
 704             new int[] {1998, Calendar.SEPTEMBER, 30, 22, 0},\r
 705             Boolean.TRUE,\r
 706 \r
 707             asuncion,\r
 708             new int[] {2000, Calendar.FEBRUARY, 28, 22, 0},\r
 709             Boolean.FALSE,\r
 710 \r
 711             asuncion,\r
 712             new int[] {2000, Calendar.FEBRUARY, 29, 22, 0},\r
 713             Boolean.TRUE,\r
 714         };\r
 715 \r
 716         String[] zone = new String[4];\r
 717 \r
 718         for (int j=0; j<DATA.length; j+=3) {\r
 719             TimeZone tz = (TimeZone)DATA[j];\r
 720             TimeZone.setDefault(tz);\r
 721             fmt.setTimeZone(tz);\r
 722             sdf.setTimeZone(tz);\r
 723 \r
 724             // Must construct the Date object AFTER setting the default zone\r
 725             int[] p = (int[])DATA[j+1];\r
 726             Calendar cal = Calendar.getInstance();\r
 727             cal.clear();\r
 728             cal.set(p[0], p[1], p[2], p[3], p[4]);\r
 729             long start = cal.getTime().getTime();\r
 730             boolean transitionExpected = ((Boolean)DATA[j+2]).booleanValue();\r
 731 \r
 732             logln(tz.getID() + ":");\r
 733             for (int i=0; i<4; ++i) {\r
 734                 Date d = new Date(start + i*ONE_HOUR);\r
 735                 zone[i] = fmt.format(d);\r
 736                 logln("" + i + ": " + sdf.format(d) + " => " + zone[i] +\r
 737                       " (" + d.getTime()/H + ")");\r
 738             }\r
 739             cal.set(p[0], p[1], p[2], 0, 0);\r
 740             for (int i=0; i<4; ++i) {\r
 741                 int h = 22+i;\r
 742                 int dom = p[2]+(h>=24?1:0);\r
 743                 h %= 24;\r
 744                 int ms = h*ONE_HOUR;\r
 745                 cal.clear();\r
 746                 cal.set(p[0], p[1], dom, 0, 0);\r
 747                 int off = tz.getOffset(GregorianCalendar.AD,\r
 748                                        cal.get(Calendar.YEAR),\r
 749                                        cal.get(Calendar.MONTH),\r
 750                                        cal.get(Calendar.DATE),\r
 751                                        cal.get(Calendar.DAY_OF_WEEK),\r
 752                                        ms);\r
 753                 cal.add(Calendar.HOUR, h);\r
 754                 int dstOffset = cal.get(Calendar.DST_OFFSET);\r
 755                 logln("h=" + h + "; dom=" + dom +\r
 756                       "; ZONE_OFFSET=" + cal.get(Calendar.ZONE_OFFSET)/H +\r
 757                       "; DST_OFFSET=" + dstOffset/H +\r
 758                       "; getOffset()=" + off/H +\r
 759                       " (" + cal.getTime().getTime()/H + ")");\r
 760             }\r
 761             if (zone[0].equals(zone[1]) &&\r
 762                 (zone[1].equals(zone[2]) != transitionExpected) &&\r
 763                 zone[2].equals(zone[3])) {\r
 764                 logln("Ok: transition " + transitionExpected);\r
 765             } else {\r
 766                 errln("FAIL: expected " +\r
 767                       (transitionExpected?"transition":"no transition"));\r
 768             }\r
 769         }\r
 770 \r
 771     // restore the initial time zone so that this test case\r
 772     // doesn't affect the others.\r
 773     TimeZone.setDefault(initialZone);\r
 774     }\r
 775 \r
 776     /**\r
 777      * TimeZone broken in last hour of year\r
 778      */\r
 779     public void Test4173604() {\r
 780         TimeZone pst = TimeZone.getTimeZone("PST");\r
 781         int o22 = pst.getOffset(1, 1998, 11, 31, Calendar.THURSDAY, 22*60*60*1000);\r
 782         int o23 = pst.getOffset(1, 1998, 11, 31, Calendar.THURSDAY, 23*60*60*1000);\r
 783         int o00 = pst.getOffset(1, 1999, 0, 1, Calendar.FRIDAY, 0);\r
 784         if (o22 != o23 || o22 != o00) {\r
 785             errln("Offsets should be the same (for PST), but got: " +\r
 786                   "12/31 22:00 " + o22 +\r
 787                   ", 12/31 23:00 " + o23 +\r
 788                   ", 01/01 00:00 " + o00);\r
 789         }\r
 790 \r
 791         GregorianCalendar cal = new GregorianCalendar();\r
 792         cal.setTimeZone(pst);\r
 793         cal.clear();\r
 794         cal.set(1998, Calendar.JANUARY, 1);\r
 795         int lastDST = cal.get(Calendar.DST_OFFSET);\r
 796         int transitions = 0;\r
 797         int delta = 5;\r
 798         while (cal.get(Calendar.YEAR) < 2000) {\r
 799             cal.add(Calendar.MINUTE, delta);\r
 800             if (cal.get(Calendar.DST_OFFSET) != lastDST) {\r
 801                 ++transitions;\r
 802                 Calendar t = (Calendar)cal.clone();\r
 803                 t.add(Calendar.MINUTE, -delta);\r
 804                 logln(t.getTime() + "  " + t.get(Calendar.DST_OFFSET));\r
 805                 logln(cal.getTime() + "  " + (lastDST=cal.get(Calendar.DST_OFFSET)));\r
 806             }\r
 807         }\r
 808         if (transitions != 4) {\r
 809             errln("Saw " + transitions + " transitions; should have seen 4");\r
 810         }\r
 811     }\r
 812 \r
 813     /**\r
 814      * getDisplayName doesn't work with unusual savings/offsets.\r
 815      */\r
 816     public void Test4176686() {\r
 817         // Construct a zone that does not observe DST but\r
 818         // that does have a DST savings (which should be ignored).\r
 819         int offset = 90 * 60000; // 1:30\r
 820         SimpleTimeZone z1 = new SimpleTimeZone(offset, "_std_zone_");\r
 821         z1.setDSTSavings(45 * 60000); // 0:45\r
 822 \r
 823         // Construct a zone that observes DST for the first 6 months.\r
 824         SimpleTimeZone z2 = new SimpleTimeZone(offset, "_dst_zone_");\r
 825         z2.setDSTSavings(45 * 60000); // 0:45\r
 826         z2.setStartRule(Calendar.JANUARY, 1, 0);\r
 827         z2.setEndRule(Calendar.JULY, 1, 0);\r
 828 \r
 829         // Also check DateFormat\r
 830         DateFormat fmt1 = new SimpleDateFormat("z");\r
 831         fmt1.setTimeZone(z1); // Format uses standard zone\r
 832         DateFormat fmt2 = new SimpleDateFormat("z");\r
 833         fmt2.setTimeZone(z2); // Format uses DST zone\r
 834         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 835         tempcal.clear();\r
 836         tempcal.set(1970, Calendar.FEBRUARY, 1);\r
 837         Date dst = tempcal.getTime(); // Time in DST\r
 838         tempcal.set(1970, Calendar.AUGUST, 1);\r
 839         Date std = tempcal.getTime(); // Time in standard\r
 840 \r
 841         // Description, Result, Expected Result\r
 842         String[] DATA = {\r
 843             "getDisplayName(false, SHORT)/std zone",\r
 844             z1.getDisplayName(false, TimeZone.SHORT), "GMT+01:30",\r
 845             "getDisplayName(false, LONG)/std zone",\r
 846             z1.getDisplayName(false, TimeZone.LONG ), "GMT+01:30",\r
 847             "getDisplayName(true, SHORT)/std zone",\r
 848             z1.getDisplayName(true, TimeZone.SHORT), "GMT+01:30",\r
 849             "getDisplayName(true, LONG)/std zone",\r
 850             z1.getDisplayName(true, TimeZone.LONG ), "GMT+01:30",\r
 851             "getDisplayName(false, SHORT)/dst zone",\r
 852             z2.getDisplayName(false, TimeZone.SHORT), "GMT+01:30",\r
 853             "getDisplayName(false, LONG)/dst zone",\r
 854             z2.getDisplayName(false, TimeZone.LONG ), "GMT+01:30",\r
 855             "getDisplayName(true, SHORT)/dst zone",\r
 856             z2.getDisplayName(true, TimeZone.SHORT), "GMT+02:15",\r
 857             "getDisplayName(true, LONG)/dst zone",\r
 858             z2.getDisplayName(true, TimeZone.LONG ), "GMT+02:15",\r
 859             "DateFormat.format(std)/std zone", fmt1.format(std), "GMT+01:30",\r
 860             "DateFormat.format(dst)/std zone", fmt1.format(dst), "GMT+01:30",\r
 861             "DateFormat.format(std)/dst zone", fmt2.format(std), "GMT+01:30",\r
 862             "DateFormat.format(dst)/dst zone", fmt2.format(dst), "GMT+02:15",\r
 863         };\r
 864 \r
 865         for (int i=0; i<DATA.length; i+=3) {\r
 866             if (!DATA[i+1].equals(DATA[i+2])) {\r
 867                 errln("FAIL: " + DATA[i] + " -> " + DATA[i+1] + ", exp " + DATA[i+2]);\r
 868             }\r
 869         }\r
 870     }\r
 871 \r
 872     /**\r
 873      * SimpleTimeZone allows invalid DOM values.\r
 874      */\r
 875     // Current orgnaization of data in zoneinfor.res allows negative\r
 876     // values from DOM so comment these tests out\r
 877     \r
 878     public void Test4184229() {\r
 879         SimpleTimeZone zone = null;\r
 880         try {\r
 881             zone = new SimpleTimeZone(0, "A", 0, -1, 0, 0, 0, 0, 0, 0);\r
 882             errln("Failed. No exception has been thrown for DOM -1 startDay");\r
 883         } catch(IllegalArgumentException e) {\r
 884             logln("(a) " + e.getMessage());\r
 885         }\r
 886         try {\r
 887             zone = new SimpleTimeZone(0, "A", 0, 0, 0, 0, 0, -1, 0, 0);\r
 888             errln("Failed. No exception has been thrown for DOM -1 endDay");\r
 889         } catch(IllegalArgumentException e) {\r
 890             logln("(b) " + e.getMessage());\r
 891         }\r
 892         try {\r
 893             zone = new SimpleTimeZone(0, "A", 0, -1, 0, 0, 0, 0, 0, 0, 1000);\r
 894             errln("Failed. No exception has been thrown for DOM -1 startDay +savings");\r
 895         } catch(IllegalArgumentException e) {\r
 896             logln("(c) " + e.getMessage());\r
 897         }\r
 898         try {\r
 899             zone = new SimpleTimeZone(0, "A", 0, 0, 0, 0, 0, -1, 0, 0, 1000);\r
 900             errln("Failed. No exception has been thrown for DOM -1 endDay +savings");\r
 901         } catch(IllegalArgumentException e) {\r
 902             logln("(d) " + e.getMessage());\r
 903         }\r
 904         // Make a valid constructor call for subsequent tests.\r
 905 \r
 906         zone = new SimpleTimeZone(0, "A", 0, 1, 0, 0, 0, 1, 0, 0);\r
 907         \r
 908         try {\r
 909             zone.setStartRule(0, -1, 0, 0);\r
 910             errln("Failed. No exception has been thrown for DOM -1 setStartRule +savings");\r
 911         } catch(IllegalArgumentException e) {\r
 912             logln("(e) " + e.getMessage());\r
 913         }\r
 914         try {\r
 915             zone.setStartRule(0, -1, 0);\r
 916             errln("Failed. No exception has been thrown for DOM -1 setStartRule");\r
 917         } catch(IllegalArgumentException e) {\r
 918             logln("(f) " + e.getMessage());\r
 919         }\r
 920         try {\r
 921             zone.setEndRule(0, -1, 0, 0);\r
 922             errln("Failed. No exception has been thrown for DOM -1 setEndRule +savings");\r
 923         } catch(IllegalArgumentException e) {\r
 924             logln("(g) " + e.getMessage());\r
 925         }\r
 926         try {\r
 927             zone.setEndRule(0, -1, 0);\r
 928             errln("Failed. No exception has been thrown for DOM -1 setEndRule");\r
 929         } catch(IllegalArgumentException e) {\r
 930             logln("(h) " + e.getMessage());\r
 931         }\r
 932         \r
 933     }\r
 934 \r
 935     /**\r
 936      * SimpleTimeZone.getOffset() throws IllegalArgumentException when to get\r
 937      * of 2/29/1996 (leap day).\r
 938      */\r
 939     public void Test4208960 () {\r
 940     TimeZone tz = TimeZone.getTimeZone("PST");\r
 941     try {\r
 942         /*int offset =*/ tz.getOffset(GregorianCalendar.AD, 1996, Calendar.FEBRUARY, 29,\r
 943                       Calendar.THURSDAY, 0);\r
 944         //offset = 0;\r
 945     } catch (IllegalArgumentException e) {\r
 946         errln("FAILED: to get TimeZone.getOffset(2/29/96)");\r
 947     }\r
 948     try {\r
 949         /*int offset =*/ tz.getOffset(GregorianCalendar.AD, 1997, Calendar.FEBRUARY, 29,\r
 950                       Calendar.THURSDAY, 0);\r
 951         //offset = 0;\r
 952         warnln("FAILED: TimeZone.getOffset(2/29/97) expected to throw Exception.");\r
 953     } catch (IllegalArgumentException e) {\r
 954         logln("got IllegalArgumentException");\r
 955     }\r
 956     }\r
 957 \r
 958     /**\r
 959      * Test to see if DateFormat understands zone equivalency groups.  It\r
 960      * might seem that this should be a DateFormat test, but it's really a\r
 961      * TimeZone test -- the changes to DateFormat are minor.\r
 962      *\r
 963      * We use two known, zones that are equivalent, where one zone has\r
 964      * localized name data, and the other doesn't, in some locale.\r
 965      */\r
 966     public void TestJ449() {\r
 967         // not used String str;\r
 968 \r
 969         // Modify the following three as necessary.  The two IDs must\r
 970         // specify two zones in the same equivalency group.  One must have\r
 971         // locale data in 'loc'; the other must not.\r
 972         String idWithLocaleData = "America/Los_Angeles";\r
 973         String idWithoutLocaleData = "PST"; // "US/Pacific";\r
 974         Locale loc = new Locale("en", "", "");\r
 975 \r
 976         TimeZone zoneWith = TimeZone.getTimeZone(idWithLocaleData);\r
 977         TimeZone zoneWithout = TimeZone.getTimeZone(idWithoutLocaleData);\r
 978         // Make sure we got valid zones\r
 979         if (!(zoneWith.getID().equals(idWithLocaleData) &&\r
 980               zoneWithout.getID().equals(idWithoutLocaleData))) {\r
 981             warnln("Fail: Unable to create zones");\r
 982         } else {\r
 983             GregorianCalendar calWith = new GregorianCalendar(zoneWith);\r
 984             GregorianCalendar calWithout = new GregorianCalendar(zoneWithout);\r
 985             SimpleDateFormat fmt =\r
 986                 new SimpleDateFormat("MMM d yyyy hh:mm a zzz", loc);\r
 987             Date date = new Date(0L);\r
 988             fmt.setCalendar(calWith);\r
 989             String strWith = fmt.format(date);\r
 990             fmt.setCalendar(calWithout);\r
 991             String strWithout = fmt.format(date);\r
 992             if (strWith.equals(strWithout)) {\r
 993                 logln("Ok: " + idWithLocaleData + " -> " +\r
 994                       strWith + "; " + idWithoutLocaleData + " -> " +\r
 995                       strWithout);\r
 996             } else {\r
 997                 errln("FAIL: " + idWithLocaleData + " -> " +\r
 998                       strWith + "; " + idWithoutLocaleData + " -> " +\r
 999                       strWithout);\r
1000             }\r
1001         }\r
1002     }\r
1003 \r
1004     /**\r
1005      * getOffset returns wrong offset for days in early 20th century\r
1006      */\r
1007     public void TestJ5134() {\r
1008         GregorianCalendar testCal = (GregorianCalendar)Calendar.getInstance();\r
1009         TimeZone icuEastern = TimeZone.getTimeZone("America/New_York");        \r
1010         testCal.setTimeZone(icuEastern);\r
1011         testCal.set(1900, Calendar.JANUARY, 1, 0, 0, 0);\r
1012         long time = testCal.getTimeInMillis();\r
1013 \r
1014         int offset = icuEastern.getOffset(time);\r
1015         if (offset != -18000000) {\r
1016             errln("FAIL: UTC offset in time zone America/New_York on Jan 1, 1900 -> " + offset);\r
1017         }\r
1018         boolean isDst = icuEastern.inDaylightTime(new Date(time));\r
1019         if (isDst) {\r
1020             errln("FAIL: DST is observed in time zone America/New_York on Jan 1, 1900");\r
1021         }\r
1022 \r
1023 //#if defined(FOUNDATION10) || defined(J2SE13)\r
1024 //#else\r
1025         if (System.getProperty("java.vendor", "").startsWith("IBM") &&\r
1026             System.getProperty("java.version", "").equals("1.4.1")) {\r
1027             // IBM JDK 1.4.1 has a bug and fails to run this test case.\r
1028             return;\r
1029         }\r
1030         java.util.TimeZone jdkEastern = java.util.TimeZone.getTimeZone("America/New_York");\r
1031         // Compare offset and DST observation with JDK and ICU for 50 years since 1900\r
1032         testCal.add(Calendar.YEAR, 50);\r
1033         long endTime = testCal.getTimeInMillis();\r
1034         int jdkOffset;\r
1035         boolean isDstJdk;\r
1036         while (time < endTime) {\r
1037             offset = icuEastern.getOffset(time);\r
1038             jdkOffset = jdkEastern.getOffset(time);\r
1039             if (offset != jdkOffset) {\r
1040                 errln("FAIL: Incompatible UTC offset -> JDK:" + jdkOffset + "/ICU:" + offset + " [" + time + "]");\r
1041             }\r
1042             Date d = new Date(time);\r
1043             isDst = icuEastern.inDaylightTime(d);\r
1044             isDstJdk = jdkEastern.inDaylightTime(d);\r
1045             if (isDst != isDstJdk) {\r
1046                 errln("FAIL: Incompatible DST -> JDK:" + isDstJdk + "/ICU:" + isDst + " [" + time + "]");\r
1047             }\r
1048             time += 24*60*60*1000L; // increment 1 day\r
1049         }\r
1050 //#endif\r
1051     }\r
1052 \r
1053     /**\r
1054      * Test setRawOffset works OK with system timezone\r
1055      */\r
1056     public void TestT5280() {\r
1057         String[] tzids = TimeZone.getAvailableIDs();\r
1058         for (int i = 0; i < tzids.length; i++) {\r
1059             TimeZone tz = TimeZone.getTimeZone(tzids[i]);\r
1060             boolean useDst = tz.useDaylightTime();\r
1061 \r
1062             // Increase offset for 30 minutes\r
1063             int newRawOffset = tz.getRawOffset() + 30*60*1000;\r
1064             try {\r
1065                 tz.setRawOffset(newRawOffset);\r
1066             } catch (Exception e) {\r
1067                 errln("FAIL: setRawOffset throws an exception");\r
1068             }\r
1069             int offset = tz.getRawOffset();\r
1070             if (offset != newRawOffset) {\r
1071                 errln("FAIL: Modified zone(" + tz.getID() + ") - getRawOffset returns " + offset + "/ Expected: " + newRawOffset);\r
1072             }\r
1073             // Ticket#5917\r
1074             // Check if DST observation status is not unexpectedly changed.\r
1075             boolean newDst = tz.useDaylightTime();\r
1076             if (useDst != newDst) {\r
1077                 errln("FAIL: Modified zone(" + tz.getID() + ") - useDaylightTime has changed from " + useDst + " to " + newDst);\r
1078             }\r
1079             // Make sure the offset is preserved in a clone\r
1080             TimeZone tzClone = (TimeZone)tz.clone();\r
1081             offset = tzClone.getRawOffset();\r
1082             if (offset != newRawOffset) {\r
1083                 errln("FAIL: Cloned modified zone(" + tz.getID() + ") - getRawOffset returns " + offset + "/ Expected: " + newRawOffset);\r
1084             }\r
1085         }\r
1086     }\r
1087 \r
1088     /*\r
1089      * Zone ID is not set by a SimpleTimeZone constructor\r
1090      */\r
1091     public void TestT5432() {\r
1092         String tzid = "MyZone";\r
1093         SimpleTimeZone stz;\r
1094 \r
1095         // 2-arg constructor\r
1096         stz = new SimpleTimeZone(0, tzid);\r
1097         if (!tzid.equals(stz.getID())) {\r
1098             errln("FAIL: Bad zone id (" + stz.getID() + ") is returned - expected ("\r
1099                     + tzid + ") [2-arg constructor]");\r
1100         }\r
1101 \r
1102         // 10-arg constructor\r
1103         stz = new SimpleTimeZone(0, tzid, 3, -1, 1, 3600000, 9, -1, 1, 3600000);\r
1104         if (!tzid.equals(stz.getID())) {\r
1105             errln("FAIL: Bad zone id (" + stz.getID() + ") is returned - expected ("\r
1106                     + tzid + ") [10-arg constructor]");\r
1107         }\r
1108 \r
1109         // 11-arg constructor\r
1110         stz = new SimpleTimeZone(0, tzid, 3, -1, 1, 3600000, 9, -1, 1, 3600000, 3600000);\r
1111         if (!tzid.equals(stz.getID())) {\r
1112             errln("FAIL: Bad zone id (" + stz.getID() + ") is returned - expected ("\r
1113                     + tzid + ") [11-arg constructor]");\r
1114         }\r
1115 \r
1116         // 13-arg constructor - this version had a problem reported by trac#5432\r
1117         stz = new SimpleTimeZone(0, tzid, 3, -1, 1, 3600000, SimpleTimeZone.WALL_TIME,\r
1118                 9, -1, 1, 3600000, SimpleTimeZone.WALL_TIME, 3600000);\r
1119         if (!tzid.equals(stz.getID())) {\r
1120             errln("FAIL: Bad zone id (" + stz.getID() + ") is returned - expected ("\r
1121                     + tzid + ") [13-arg constructor]");\r
1122         }\r
1123     }\r
1124     \r
1125     // test bug #4265\r
1126     public void TestJohannesburg() {\r
1127         String j_id="Africa/Johannesburg";\r
1128         TimeZone johannesburg = TimeZone.getTimeZone(j_id);\r
1129         final int ONE_HOUR = 60*60*1000;\r
1130         int expectedOffset = ONE_HOUR*2;  // GMT+2 - NO DST\r
1131         int offset = johannesburg.getOffset(GregorianCalendar.AD,2007,Calendar.JULY,5,Calendar.THURSDAY,0);        \r
1132         \r
1133         if(offset != expectedOffset) {\r
1134             errln("FAIL: zone " + j_id +" returned offset in July " + offset +", expected "+expectedOffset);\r
1135         } else {\r
1136             logln("OK: zone " + j_id +" returned offset in July: " + offset);\r
1137         }\r
1138 \r
1139         int offset2 = johannesburg.getOffset(GregorianCalendar.AD,2007,Calendar.DECEMBER,12,Calendar.WEDNESDAY,0);\r
1140 \r
1141         if(offset2 != expectedOffset) {\r
1142             errln("FAIL: zone " + j_id +" returned offset in December " + offset2 +", expected "+expectedOffset);\r
1143         } else {\r
1144             logln("OK: zone " + j_id +" returned offset in December: " + offset2);\r
1145         }\r
1146 \r
1147     }\r
1148 }\r
1149 \r
1150 //eof\r