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

   1 /**\r
   2  *******************************************************************************\r
   3  * Copyright (C) 2000-2009, International Business Machines Corporation and    *\r
   4  * others. All Rights Reserved.                                                *\r
   5  *******************************************************************************\r
   6  */\r
   7 package com.ibm.icu.dev.test.calendar;\r
   8 \r
   9 import java.io.ByteArrayInputStream;\r
  10 import java.io.ByteArrayOutputStream;\r
  11 import java.io.IOException;\r
  12 import java.io.ObjectInputStream;\r
  13 import java.io.ObjectOutputStream;\r
  14 import java.util.Arrays;\r
  15 import java.util.Date;\r
  16 import java.util.HashSet;\r
  17 import java.util.Locale;\r
  18 import java.util.MissingResourceException;\r
  19 \r
  20 import com.ibm.icu.text.DateFormat;\r
  21 import com.ibm.icu.text.NumberFormat;\r
  22 import com.ibm.icu.text.SimpleDateFormat;\r
  23 import com.ibm.icu.util.Calendar;\r
  24 import com.ibm.icu.util.GregorianCalendar;\r
  25 import com.ibm.icu.util.SimpleTimeZone;\r
  26 import com.ibm.icu.util.TimeZone;\r
  27 import com.ibm.icu.util.ULocale;\r
  28 \r
  29 /**\r
  30  * @test 1.32 99/11/14\r
  31  * @bug 4031502 4035301 4040996 4051765 4059654 4061476 4070502 4071197 4071385\r
  32  * 4073929 4083167 4086724 4092362 4095407 4096231 4096539 4100311 4103271\r
  33  * 4106136 4108764 4114578 4118384 4125881 4125892 4136399 4141665 4142933\r
  34  * 4145158 4145983 4147269 4149677 4162587 4165343 4166109 4167060 4173516\r
  35  * 4174361 4177484 4197699 4209071 4288792\r
  36  */\r
  37 public class CalendarRegression extends com.ibm.icu.dev.test.TestFmwk {\r
  38 \r
  39     public static void main(String[] args) throws Exception {\r
  40         new CalendarRegression().run(args);\r
  41     }\r
  42     static final String[] FIELD_NAME = {\r
  43             "ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH",\r
  44             "DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK",\r
  45             "DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR", "HOUR_OF_DAY",\r
  46             "MINUTE", "SECOND", "MILLISECOND", "ZONE_OFFSET",\r
  47             "DST_OFFSET", "YEAR_WOY", "DOW_LOCAL", "EXTENDED_YEAR",\r
  48             "JULIAN_DAY", "MILLISECONDS_IN_DAY"\r
  49         };\r
  50 \r
  51 \r
  52     /*\r
  53       Synopsis: java.sql.Timestamp constructor works wrong on Windows 95\r
  54 \r
  55       ==== Here is the test ==== \r
  56       public static void main (String args[]) { \r
  57         java.sql.Timestamp t= new java.sql.Timestamp(0,15,5,5,8,13,123456700); \r
  58         logln("expected=1901-04-05 05:08:13.1234567"); \r
  59         logln(" result="+t); \r
  60       } \r
  61       \r
  62       ==== Here is the output of the test on Solaris or NT ==== \r
  63       expected=1901-04-05 05:08:13.1234567 \r
  64       result=1901-04-05 05:08:13.1234567 \r
  65       \r
  66       ==== Here is the output of the test on Windows95 ==== \r
  67       expected=1901-04-05 05:08:13.1234567 \r
  68       result=1901-04-05 06:08:13.1234567 \r
  69       */\r
  70 \r
  71     public void Test4031502() {\r
  72         try{\r
  73             // This bug actually occurs on Windows NT as well, and doesn't\r
  74             // require the host zone to be set; it can be set in Java.\r
  75             String[] ids = TimeZone.getAvailableIDs();\r
  76             boolean bad = false;\r
  77             for (int i=0; i<ids.length; ++i) {\r
  78                 TimeZone zone = TimeZone.getTimeZone(ids[i]);\r
  79                 GregorianCalendar cal = new GregorianCalendar(zone);\r
  80                 cal.clear();\r
  81                 cal.set(1900, 15, 5, 5, 8, 13);\r
  82                 if (cal.get(Calendar.HOUR) != 5) {\r
  83                     logln("Fail: " + zone.getID() + " " +\r
  84                           zone.useDaylightTime() + "; DST_OFFSET = " +\r
  85                           cal.get(Calendar.DST_OFFSET) / (60*60*1000.0) + "; ZONE_OFFSET = " +\r
  86                           cal.get(Calendar.ZONE_OFFSET) / (60*60*1000.0) + "; getRawOffset() = " +\r
  87                           zone.getRawOffset() / (60*60*1000.0) +\r
  88                           "; HOUR = " + cal.get(Calendar.HOUR));\r
  89                     cal.clear();\r
  90                     cal.set(1900, 15, 5, 5, 8, 13);\r
  91                     if (cal.get(Calendar.HOUR) != 5) {\r
  92                         logln("Fail: " + zone.getID() + " " +\r
  93                               zone.useDaylightTime() + "; DST_OFFSET = " +\r
  94                               cal.get(Calendar.DST_OFFSET) / (60*60*1000.0) + "; ZONE_OFFSET = " +\r
  95                               cal.get(Calendar.ZONE_OFFSET) / (60*60*1000.0) + "; getRawOffset() = " +\r
  96                               zone.getRawOffset() / (60*60*1000.0) +\r
  97                               "; HOUR = " + cal.get(Calendar.HOUR));\r
  98                         cal.clear();\r
  99                         cal.set(1900, 15, 5, 5, 8, 13);\r
 100                         logln("ms = " + cal.getTime() + " (" + cal.getTime().getTime() + ")");\r
 101                         cal.get(Calendar.HOUR);\r
 102                         java.util.GregorianCalendar cal2 = new java.util.GregorianCalendar(java.util.TimeZone.getTimeZone(ids[i]));\r
 103                         cal2.clear();\r
 104                         cal2.set(1900, 15, 5, 5, 8, 13);\r
 105                         cal2.get(Calendar.HOUR);\r
 106                         logln("java.util.GC: " + zone.getID() + " " +\r
 107                             zone.useDaylightTime() + "; DST_OFFSET = " +\r
 108                             cal2.get(Calendar.DST_OFFSET) / (60*60*1000.0) + "; ZONE_OFFSET = " +\r
 109                             cal2.get(Calendar.ZONE_OFFSET) / (60*60*1000.0) + "; getRawOffset() = " +\r
 110                             zone.getRawOffset() / (60*60*1000.0) +\r
 111                             "; HOUR = " + cal.get(Calendar.HOUR));\r
 112                         logln("ms = " + cal2.getTime() + " (" + cal2.getTime().getTime() + ")");\r
 113                         bad = true;\r
 114                     } else if (false) { // Change to true to debug\r
 115                         logln("OK: " + zone.getID() + " " +\r
 116                               zone.useDaylightTime() + " " +\r
 117                               cal.get(Calendar.DST_OFFSET) / (60*60*1000) + " " +\r
 118                               zone.getRawOffset() / (60*60*1000) +\r
 119                               ": HOUR = " + cal.get(Calendar.HOUR));\r
 120                     }\r
 121                 }\r
 122                 if (bad) errln("TimeZone problems with GC");\r
 123             }\r
 124         } catch (MissingResourceException e) {\r
 125             warnln("Could not load data. "+ e.getMessage());\r
 126         }\r
 127     }\r
 128 \r
 129     public void Test4035301() {\r
 130         \r
 131         try {\r
 132             GregorianCalendar c = new GregorianCalendar(98, 8, 7);\r
 133             GregorianCalendar d = new GregorianCalendar(98, 8, 7);\r
 134             if (c.after(d) ||\r
 135                 c.after(c) ||\r
 136                 c.before(d) ||\r
 137                 c.before(c) ||\r
 138                 !c.equals(c) ||\r
 139                 !c.equals(d))\r
 140                 errln("Fail");\r
 141         } catch (Exception e) {\r
 142             // TODO Auto-generated catch block\r
 143             warnln("Could not load data. "+ e.getMessage());\r
 144         }\r
 145     }\r
 146 \r
 147     public void Test4040996() {\r
 148         try {\r
 149             String[] ids = TimeZone.getAvailableIDs(-8 * 60 * 60 * 1000);\r
 150             SimpleTimeZone pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, ids[0]);\r
 151             pdt.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);\r
 152             pdt.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);\r
 153             Calendar calendar = new GregorianCalendar(pdt);\r
 154 \r
 155             calendar.set(Calendar.MONTH,3);\r
 156             calendar.set(Calendar.DAY_OF_MONTH,18);\r
 157             calendar.set(Calendar.SECOND, 30);\r
 158 \r
 159             logln("MONTH: " + calendar.get(Calendar.MONTH));\r
 160             logln("DAY_OF_MONTH: " + \r
 161                                calendar.get(Calendar.DAY_OF_MONTH));\r
 162             logln("MINUTE: " + calendar.get(Calendar.MINUTE));\r
 163             logln("SECOND: " + calendar.get(Calendar.SECOND));\r
 164 \r
 165             calendar.add(Calendar.SECOND,6);\r
 166             //This will print out todays date for MONTH and DAY_OF_MONTH\r
 167             //instead of the date it was set to.\r
 168             //This happens when adding MILLISECOND or MINUTE also\r
 169             logln("MONTH: " + calendar.get(Calendar.MONTH));\r
 170             logln("DAY_OF_MONTH: " + \r
 171                                calendar.get(Calendar.DAY_OF_MONTH));\r
 172             logln("MINUTE: " + calendar.get(Calendar.MINUTE));\r
 173             logln("SECOND: " + calendar.get(Calendar.SECOND));\r
 174             if (calendar.get(Calendar.MONTH) != 3 ||\r
 175                 calendar.get(Calendar.DAY_OF_MONTH) != 18 ||\r
 176                 calendar.get(Calendar.SECOND) != 36)\r
 177                 errln("Fail: Calendar.add misbehaves");\r
 178         } catch (Exception e) {\r
 179             warnln("Could not load data. "+ e.getMessage());\r
 180         }\r
 181     }\r
 182 \r
 183     public void Test4051765() {\r
 184         try {\r
 185             Calendar cal = Calendar.getInstance();\r
 186             cal.setLenient(false);\r
 187             cal.set(Calendar.DAY_OF_WEEK, 0);\r
 188             try {\r
 189                 cal.getTime();\r
 190                 errln("Fail: DAY_OF_WEEK 0 should be disallowed");\r
 191             }\r
 192             catch (IllegalArgumentException e) {\r
 193                 return;\r
 194             }\r
 195         } catch (Exception e) {\r
 196             // TODO Auto-generated catch block\r
 197             warnln("Could not load data. "+ e.getMessage());\r
 198         }\r
 199     }\r
 200     \r
 201     /*\r
 202      * User error - no bug here public void Test4059524() { // Create calendar\r
 203      * for April 10, 1997 GregorianCalendar calendar = new GregorianCalendar(); //\r
 204      * print out a bunch of interesting things logln("ERA: " +\r
 205      * calendar.get(calendar.ERA)); logln("YEAR: " +\r
 206      * calendar.get(calendar.YEAR)); logln("MONTH: " +\r
 207      * calendar.get(calendar.MONTH)); logln("WEEK_OF_YEAR: " +\r
 208      * calendar.get(calendar.WEEK_OF_YEAR)); logln("WEEK_OF_MONTH: " +\r
 209      * calendar.get(calendar.WEEK_OF_MONTH)); logln("DATE: " +\r
 210      * calendar.get(calendar.DATE)); logln("DAY_OF_MONTH: " +\r
 211      * calendar.get(calendar.DAY_OF_MONTH)); logln("DAY_OF_YEAR: " +\r
 212      * calendar.get(calendar.DAY_OF_YEAR)); logln("DAY_OF_WEEK: " +\r
 213      * calendar.get(calendar.DAY_OF_WEEK)); logln("DAY_OF_WEEK_IN_MONTH: " +\r
 214      * calendar.get(calendar.DAY_OF_WEEK_IN_MONTH)); logln("AM_PM: " +\r
 215      * calendar.get(calendar.AM_PM)); logln("HOUR: " +\r
 216      * calendar.get(calendar.HOUR)); logln("HOUR_OF_DAY: " +\r
 217      * calendar.get(calendar.HOUR_OF_DAY)); logln("MINUTE: " +\r
 218      * calendar.get(calendar.MINUTE)); logln("SECOND: " +\r
 219      * calendar.get(calendar.SECOND)); logln("MILLISECOND: " +\r
 220      * calendar.get(calendar.MILLISECOND)); logln("ZONE_OFFSET: " +\r
 221      * (calendar.get(calendar.ZONE_OFFSET)/(60*60*1000))); logln("DST_OFFSET: " +\r
 222      * (calendar.get(calendar.DST_OFFSET)/(60*60*1000))); calendar = new\r
 223      * GregorianCalendar(1997,3,10); calendar.getTime(); logln("April 10,\r
 224      * 1997"); logln("ERA: " + calendar.get(calendar.ERA)); logln("YEAR: " +\r
 225      * calendar.get(calendar.YEAR)); logln("MONTH: " +\r
 226      * calendar.get(calendar.MONTH)); logln("WEEK_OF_YEAR: " +\r
 227      * calendar.get(calendar.WEEK_OF_YEAR)); logln("WEEK_OF_MONTH: " +\r
 228      * calendar.get(calendar.WEEK_OF_MONTH)); logln("DATE: " +\r
 229      * calendar.get(calendar.DATE)); logln("DAY_OF_MONTH: " +\r
 230      * calendar.get(calendar.DAY_OF_MONTH)); logln("DAY_OF_YEAR: " +\r
 231      * calendar.get(calendar.DAY_OF_YEAR)); logln("DAY_OF_WEEK: " +\r
 232      * calendar.get(calendar.DAY_OF_WEEK)); logln("DAY_OF_WEEK_IN_MONTH: " +\r
 233      * calendar.get(calendar.DAY_OF_WEEK_IN_MONTH)); logln("AM_PM: " +\r
 234      * calendar.get(calendar.AM_PM)); logln("HOUR: " +\r
 235      * calendar.get(calendar.HOUR)); logln("HOUR_OF_DAY: " +\r
 236      * calendar.get(calendar.HOUR_OF_DAY)); logln("MINUTE: " +\r
 237      * calendar.get(calendar.MINUTE)); logln("SECOND: " +\r
 238      * calendar.get(calendar.SECOND)); logln("MILLISECOND: " +\r
 239      * calendar.get(calendar.MILLISECOND)); logln("ZONE_OFFSET: " +\r
 240      * (calendar.get(calendar.ZONE_OFFSET)/(60*60*1000))); // in hours\r
 241      * logln("DST_OFFSET: " + (calendar.get(calendar.DST_OFFSET)/(60*60*1000))); //\r
 242      * in hours }\r
 243      */\r
 244 \r
 245     public void Test4059654() {\r
 246    //     try {\r
 247             // work around bug for jdk1.4 on solaris 2.6, which uses funky\r
 248             // timezone names\r
 249             // jdk1.4.1 will drop support for 2.6 so we should be ok when it\r
 250             // comes out\r
 251             java.util.TimeZone javazone = java.util.TimeZone.getTimeZone("GMT");\r
 252             TimeZone icuzone = TimeZone.getTimeZone("GMT");\r
 253 \r
 254             GregorianCalendar gc = new GregorianCalendar(icuzone);\r
 255             \r
 256             gc.set(1997, 3, 1, 15, 16, 17); // April 1, 1997\r
 257 \r
 258             gc.set(Calendar.HOUR, 0);\r
 259             gc.set(Calendar.AM_PM, Calendar.AM);\r
 260             gc.set(Calendar.MINUTE, 0);\r
 261             gc.set(Calendar.SECOND, 0);\r
 262             gc.set(Calendar.MILLISECOND, 0);\r
 263 \r
 264             Date cd = gc.getTime();\r
 265             java.util.Calendar cal = java.util.Calendar.getInstance(javazone);\r
 266             cal.clear();\r
 267             cal.set(1997, 3, 1, 0, 0, 0);\r
 268             Date exp = cal.getTime();\r
 269             if (!cd.equals(exp))\r
 270                 errln("Fail: Calendar.set broken. Got " + cd + " Want " + exp);\r
 271    //     } catch (RuntimeException e) {\r
 272             // TODO Auto-generated catch block\r
 273    //         e.printStackTrace();\r
 274   //      }\r
 275     }\r
 276 \r
 277     public void Test4061476() {\r
 278         SimpleDateFormat fmt = new SimpleDateFormat("ddMMMyy", Locale.UK);\r
 279         Calendar cal = GregorianCalendar.getInstance(TimeZone.getTimeZone("GMT"), \r
 280                                                      Locale.UK);\r
 281         fmt.setCalendar(cal);\r
 282         try\r
 283             {\r
 284                 Date date = fmt.parse("29MAY97");\r
 285                 cal.setTime(date);\r
 286             }\r
 287         catch (Exception e) {\r
 288             System.out.print("");\r
 289         }\r
 290         cal.set(Calendar.HOUR_OF_DAY, 13);\r
 291         logln("Hour: "+cal.get(Calendar.HOUR_OF_DAY));\r
 292         cal.add(Calendar.HOUR_OF_DAY, 6);\r
 293         logln("Hour: "+cal.get(Calendar.HOUR_OF_DAY));\r
 294         if (cal.get(Calendar.HOUR_OF_DAY) != 19)\r
 295             errln("Fail: Want 19 Got " + cal.get(Calendar.HOUR_OF_DAY));\r
 296     }\r
 297 \r
 298     public void Test4070502() {\r
 299         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 300         tempcal.clear();\r
 301         tempcal.set(1998, 0, 30);\r
 302         Date d = getAssociatedDate(tempcal.getTime());\r
 303         Calendar cal = new GregorianCalendar();\r
 304         cal.setTime(d);\r
 305         if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY ||\r
 306             cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY)\r
 307             errln("Fail: Want weekday Got " + d);\r
 308     }\r
 309 \r
 310     /**\r
 311      * Get the associated date starting from a specified date NOTE: the\r
 312      * unnecessary "getTime()'s" below are a work-around for a bug in jdk 1.1.3\r
 313      * (and probably earlier versions also)\r
 314      * <p>\r
 315      * \r
 316      * @param d\r
 317      *            The date to start from\r
 318      */\r
 319     public static Date getAssociatedDate(Date d) {\r
 320         GregorianCalendar cal = new GregorianCalendar();\r
 321         cal.setTime(d);\r
 322         //cal.add(field, amount); //<-- PROBLEM SEEN WITH field = DATE,MONTH\r
 323         // cal.getTime(); // <--- REMOVE THIS TO SEE BUG\r
 324         while (true) {\r
 325             int wd = cal.get(Calendar.DAY_OF_WEEK);\r
 326             if (wd == Calendar.SATURDAY || wd == Calendar.SUNDAY) {\r
 327                 cal.add(Calendar.DATE, 1);\r
 328                 // cal.getTime();\r
 329             }\r
 330             else\r
 331                 break;\r
 332         }\r
 333         return cal.getTime();\r
 334     }\r
 335 \r
 336     public void Test4071197() {\r
 337         dowTest(false);\r
 338         dowTest(true);\r
 339     }\r
 340 \r
 341     void dowTest(boolean lenient) {\r
 342         GregorianCalendar cal = new GregorianCalendar();\r
 343         cal.set(1997, Calendar.AUGUST, 12); // Wednesday\r
 344         // cal.getTime(); // Force update\r
 345         cal.setLenient(lenient);\r
 346         cal.set(1996, Calendar.DECEMBER, 1); // Set the date to be December 1,\r
 347                                              // 1996\r
 348         int dow = cal.get(Calendar.DAY_OF_WEEK);\r
 349         int min = cal.getMinimum(Calendar.DAY_OF_WEEK);\r
 350         int max = cal.getMaximum(Calendar.DAY_OF_WEEK);\r
 351         logln(cal.getTime().toString());\r
 352         if (min != Calendar.SUNDAY || max != Calendar.SATURDAY)\r
 353             errln("FAIL: Min/max bad");\r
 354         if (dow < min || dow > max) \r
 355             errln("FAIL: Day of week " + dow + " out of range");\r
 356         if (dow != Calendar.SUNDAY) \r
 357             errln("FAIL: Day of week should be SUNDAY Got " + dow);\r
 358     }\r
 359 \r
 360     public void Test4071385() {\r
 361     // work around bug for jdk1.4 on solaris 2.6, which uses funky timezone\r
 362     // names\r
 363     // jdk1.4.1 will drop support for 2.6 so we should be ok when it comes out\r
 364     java.util.TimeZone javazone = java.util.TimeZone.getTimeZone("GMT");\r
 365     TimeZone icuzone = TimeZone.getTimeZone("GMT");\r
 366 \r
 367         Calendar cal = Calendar.getInstance(icuzone);\r
 368         java.util.Calendar tempcal = java.util.Calendar.getInstance(javazone);\r
 369         tempcal.clear();\r
 370         tempcal.set(1998, Calendar.JUNE, 24);\r
 371         cal.setTime(tempcal.getTime());\r
 372         cal.set(Calendar.MONTH, Calendar.NOVEMBER); // change a field\r
 373         logln(cal.getTime().toString());\r
 374         tempcal.set(1998, Calendar.NOVEMBER, 24);\r
 375         if (!cal.getTime().equals(tempcal.getTime()))\r
 376             errln("Fail");\r
 377     }\r
 378 \r
 379     public void Test4073929() {\r
 380         GregorianCalendar foo1 = new GregorianCalendar(1997, 8, 27);\r
 381         foo1.add(Calendar.DAY_OF_MONTH, +1);\r
 382         int testyear = foo1.get(Calendar.YEAR);\r
 383         int testmonth = foo1.get(Calendar.MONTH);\r
 384         int testday = foo1.get(Calendar.DAY_OF_MONTH);\r
 385         if (testyear != 1997 ||\r
 386             testmonth != 8 ||\r
 387             testday != 28)\r
 388             errln("Fail: Calendar not initialized");\r
 389     }\r
 390 \r
 391     public void Test4083167() {\r
 392         TimeZone saveZone = TimeZone.getDefault();\r
 393         try {\r
 394             TimeZone.setDefault(TimeZone.getTimeZone("UTC"));\r
 395             Date firstDate = new Date();\r
 396             Calendar cal = new GregorianCalendar();\r
 397             cal.setTime(firstDate);\r
 398             long firstMillisInDay = cal.get(Calendar.HOUR_OF_DAY) * 3600000L +\r
 399                 cal.get(Calendar.MINUTE) * 60000L +\r
 400                 cal.get(Calendar.SECOND) * 1000L +\r
 401                 cal.get(Calendar.MILLISECOND);\r
 402             \r
 403             logln("Current time: " + firstDate.toString());\r
 404 \r
 405             for (int validity=0; validity<30; validity++) {\r
 406                 Date lastDate = new Date(firstDate.getTime() +\r
 407                                          (long)validity*1000*24*60*60);\r
 408                 cal.setTime(lastDate);\r
 409                 long millisInDay = cal.get(Calendar.HOUR_OF_DAY) * 3600000L +\r
 410                     cal.get(Calendar.MINUTE) * 60000L +\r
 411                     cal.get(Calendar.SECOND) * 1000L +\r
 412                     cal.get(Calendar.MILLISECOND);\r
 413                 if (firstMillisInDay != millisInDay) \r
 414                     errln("Day has shifted " + lastDate);\r
 415             }\r
 416         }\r
 417         finally {\r
 418             TimeZone.setDefault(saveZone);\r
 419         }\r
 420     }\r
 421 \r
 422     public void Test4086724() {\r
 423         SimpleDateFormat date;\r
 424         TimeZone saveZone = TimeZone.getDefault();\r
 425         Locale saveLocale = Locale.getDefault();\r
 426         try {\r
 427             Locale.setDefault(Locale.UK); \r
 428             TimeZone.setDefault(TimeZone.getTimeZone("GMT"));\r
 429             date=new SimpleDateFormat("dd MMM yyy (zzzz) 'is in week' ww"); \r
 430             Calendar cal=Calendar.getInstance(); \r
 431             cal.set(1997,Calendar.SEPTEMBER,30); \r
 432             Date now=cal.getTime(); \r
 433             logln(date.format(now)); \r
 434             cal.set(1997,Calendar.JANUARY,1); \r
 435             now=cal.getTime(); \r
 436             logln(date.format(now)); \r
 437             cal.set(1997,Calendar.JANUARY,8); \r
 438             now=cal.getTime(); \r
 439             logln(date.format(now)); \r
 440             cal.set(1996,Calendar.DECEMBER,31); \r
 441             now=cal.getTime(); \r
 442             logln(date.format(now)); \r
 443         }\r
 444         finally {\r
 445             Locale.setDefault(saveLocale);\r
 446             TimeZone.setDefault(saveZone);\r
 447         }\r
 448         logln("*** THE RESULTS OF THIS TEST MUST BE VERIFIED MANUALLY ***");\r
 449     }\r
 450 \r
 451     public void Test4092362() {\r
 452         GregorianCalendar cal1 = new GregorianCalendar(1997, 10, 11, 10, 20, 40); \r
 453         /*\r
 454          * cal1.set( Calendar.YEAR, 1997 ); cal1.set( Calendar.MONTH, 10 );\r
 455          * cal1.set( Calendar.DATE, 11 ); cal1.set( Calendar.HOUR, 10 );\r
 456          * cal1.set( Calendar.MINUTE, 20 ); cal1.set( Calendar.SECOND, 40 );\r
 457          */\r
 458 \r
 459         logln( " Cal1 = " + cal1.getTime().getTime() ); \r
 460         logln( " Cal1 time in ms = " + cal1.get(Calendar.MILLISECOND) ); \r
 461         for( int k = 0; k < 100 ; k++ ) {\r
 462             System.out.print(""); \r
 463         }\r
 464 \r
 465         GregorianCalendar cal2 = new GregorianCalendar(1997, 10, 11, 10, 20, 40); \r
 466         /*\r
 467          * cal2.set( Calendar.YEAR, 1997 ); cal2.set( Calendar.MONTH, 10 );\r
 468          * cal2.set( Calendar.DATE, 11 ); cal2.set( Calendar.HOUR, 10 );\r
 469          * cal2.set( Calendar.MINUTE, 20 ); cal2.set( Calendar.SECOND, 40 );\r
 470          */\r
 471 \r
 472         logln( " Cal2 = " + cal2.getTime().getTime() ); \r
 473         logln( " Cal2 time in ms = " + cal2.get(Calendar.MILLISECOND) ); \r
 474         if( !cal1.equals( cal2 ) ) \r
 475             errln("Fail: Milliseconds randomized");\r
 476     }\r
 477 \r
 478     public void Test4095407() {\r
 479         GregorianCalendar a = new GregorianCalendar(1997,Calendar.NOVEMBER, 13);\r
 480         int dow = a.get(Calendar.DAY_OF_WEEK);\r
 481         if (dow != Calendar.THURSDAY)\r
 482             errln("Fail: Want THURSDAY Got " + dow);\r
 483     }\r
 484 \r
 485     public void Test4096231() {\r
 486         TimeZone GMT = TimeZone.getTimeZone("GMT");\r
 487         TimeZone PST = TimeZone.getTimeZone("PST");\r
 488         int sec = 0, min = 0, hr = 0, day = 1, month = 10, year = 1997;\r
 489                             \r
 490         Calendar cal1 = new GregorianCalendar(PST);\r
 491         cal1.setTime(new Date(880698639000L));\r
 492         int p;\r
 493         logln("PST 1 is: " + (p=cal1.get(Calendar.HOUR_OF_DAY)));\r
 494         cal1.setTimeZone(GMT);\r
 495         // Issue 1: Changing the timezone doesn't change the\r
 496         //          represented time.\r
 497         int h1,h2;\r
 498         logln("GMT 1 is: " + (h1=cal1.get(Calendar.HOUR_OF_DAY)));\r
 499         cal1.setTime(new Date(880698639000L));\r
 500         logln("GMT 2 is: " + (h2=cal1.get(Calendar.HOUR_OF_DAY)));\r
 501         // Note: This test had a bug in it. It wanted h1!=h2, when\r
 502         // what was meant was h1!=p. Fixed this concurrent with fix\r
 503         // to 4177484.\r
 504         if (p == h1 || h1 != h2)\r
 505             errln("Fail: Hour same in different zones");\r
 506 \r
 507         Calendar cal2 = new GregorianCalendar(GMT);\r
 508         Calendar cal3 = new GregorianCalendar(PST);\r
 509         cal2.set(Calendar.MILLISECOND, 0);\r
 510         cal3.set(Calendar.MILLISECOND, 0);\r
 511 \r
 512         cal2.set(cal1.get(Calendar.YEAR),\r
 513                  cal1.get(Calendar.MONTH),\r
 514                  cal1.get(Calendar.DAY_OF_MONTH),\r
 515                  cal1.get(Calendar.HOUR_OF_DAY),\r
 516                  cal1.get(Calendar.MINUTE),\r
 517                  cal1.get(Calendar.SECOND));\r
 518 \r
 519         long t1,t2,t3,t4;\r
 520         logln("RGMT 1 is: " + (t1=cal2.getTime().getTime()));\r
 521         cal3.set(year, month, day, hr, min, sec);\r
 522         logln("RPST 1 is: " + (t2=cal3.getTime().getTime()));\r
 523         cal3.setTimeZone(GMT);\r
 524         logln("RGMT 2 is: " + (t3=cal3.getTime().getTime()));\r
 525         cal3.set(cal1.get(Calendar.YEAR),\r
 526                  cal1.get(Calendar.MONTH),\r
 527                  cal1.get(Calendar.DAY_OF_MONTH),\r
 528                  cal1.get(Calendar.HOUR_OF_DAY),\r
 529                  cal1.get(Calendar.MINUTE),\r
 530                  cal1.get(Calendar.SECOND));\r
 531         // Issue 2: Calendar continues to use the timezone in its\r
 532         //          constructor for set() conversions, regardless\r
 533         //          of calls to setTimeZone()\r
 534         logln("RGMT 3 is: " + (t4=cal3.getTime().getTime()));\r
 535         if (t1 == t2 ||\r
 536             t1 != t4 ||\r
 537             t2 != t3)\r
 538             errln("Fail: Calendar zone behavior faulty");\r
 539     }\r
 540 \r
 541     public void Test4096539() {\r
 542         int[] y = {31,28,31,30,31,30,31,31,30,31,30,31};\r
 543 \r
 544         for (int x=0;x<12;x++) {\r
 545             GregorianCalendar gc = new \r
 546                 GregorianCalendar(1997,x,y[x]);\r
 547             int m1,m2;\r
 548             log((m1=gc.get(Calendar.MONTH)+1)+"/"+\r
 549                              gc.get(Calendar.DATE)+"/"+gc.get(Calendar.YEAR)+\r
 550                              " + 1mo = ");\r
 551 \r
 552             gc.add(Calendar.MONTH, 1);\r
 553             logln((m2=gc.get(Calendar.MONTH)+1)+"/"+\r
 554                                gc.get(Calendar.DATE)+"/"+gc.get(Calendar.YEAR)\r
 555                                );\r
 556             int m = (m1 % 12) + 1;\r
 557             if (m2 != m)\r
 558                 errln("Fail: Want " + m + " Got " + m2);\r
 559         }\r
 560         \r
 561     }\r
 562 \r
 563     public void Test4100311() {\r
 564         GregorianCalendar cal = (GregorianCalendar)Calendar.getInstance();\r
 565         cal.set(Calendar.YEAR, 1997);\r
 566         cal.set(Calendar.DAY_OF_YEAR, 1);\r
 567         Date d = cal.getTime();             // Should be Jan 1\r
 568         logln(d.toString());\r
 569         if (cal.get(Calendar.DAY_OF_YEAR) != 1)\r
 570             errln("Fail: DAY_OF_YEAR not set");\r
 571     }\r
 572 \r
 573     public void Test4103271() {\r
 574         SimpleDateFormat sdf = new SimpleDateFormat(); \r
 575         int numYears=40, startYear=1997, numDays=15; \r
 576         String output, testDesc; \r
 577         GregorianCalendar testCal = (GregorianCalendar)Calendar.getInstance(); \r
 578         testCal.clear();\r
 579         sdf.setCalendar(testCal); \r
 580         sdf.applyPattern("d MMM yyyy"); \r
 581         boolean fail = false;\r
 582         for (int firstDay=1; firstDay<=2; firstDay++) { \r
 583             for (int minDays=1; minDays<=7; minDays++) { \r
 584                 testCal.setMinimalDaysInFirstWeek(minDays); \r
 585                 testCal.setFirstDayOfWeek(firstDay); \r
 586                 testDesc = ("Test" + String.valueOf(firstDay) + String.valueOf(minDays)); \r
 587                 logln(testDesc + " => 1st day of week=" +\r
 588                                    String.valueOf(firstDay) +\r
 589                                    ", minimum days in first week=" +\r
 590                                    String.valueOf(minDays)); \r
 591                 for (int j=startYear; j<=startYear+numYears; j++) { \r
 592                     testCal.set(j,11,25); \r
 593                     for(int i=0; i<numDays; i++) { \r
 594                         testCal.add(Calendar.DATE,1); \r
 595                         String calWOY; \r
 596                         int actWOY = testCal.get(Calendar.WEEK_OF_YEAR);\r
 597                         if (actWOY < 1 || actWOY > 53) {\r
 598                             Date d = testCal.getTime(); \r
 599                             calWOY = String.valueOf(actWOY); \r
 600                             output = testDesc + " - " + sdf.format(d) + "\t"; \r
 601                             output = output + "\t" + calWOY; \r
 602                             logln(output); \r
 603                             fail = true;\r
 604                         }\r
 605                     } \r
 606                 } \r
 607             } \r
 608         } \r
 609 \r
 610         int[] DATA = {\r
 611             3, 52, 52, 52, 52, 52, 52, 52,\r
 612                 1,  1,  1,  1,  1,  1,  1,\r
 613                 2,  2,  2,  2,  2,  2,  2,\r
 614             4, 52, 52, 52, 52, 52, 52, 52,\r
 615                53, 53, 53, 53, 53, 53, 53,\r
 616                 1,  1,  1,  1,  1,  1,  1,\r
 617         };\r
 618         testCal.setFirstDayOfWeek(Calendar.SUNDAY);\r
 619         for (int j=0; j<DATA.length; j+=22) {\r
 620             logln("Minimal days in first week = " + DATA[j] +\r
 621                                "  Week starts on Sunday");\r
 622             testCal.setMinimalDaysInFirstWeek(DATA[j]);\r
 623             testCal.set(1997, Calendar.DECEMBER, 21);\r
 624             for (int i=0; i<21; ++i) {\r
 625                 int woy = testCal.get(Calendar.WEEK_OF_YEAR);\r
 626                 log(testCal.getTime() + " " + woy);\r
 627                 if (woy != DATA[j + 1 + i]) {\r
 628                     log(" ERROR");\r
 629                     fail = true;\r
 630                 }\r
 631                 //logln();\r
 632                 \r
 633                 // Now compute the time from the fields, and make sure we\r
 634                 // get the same answer back. This is a round-trip test.\r
 635                 Date save = testCal.getTime();\r
 636                 testCal.clear();\r
 637                 testCal.set(Calendar.YEAR, DATA[j+1+i] < 25 ? 1998 : 1997);\r
 638                 testCal.set(Calendar.WEEK_OF_YEAR, DATA[j+1+i]);\r
 639                 testCal.set(Calendar.DAY_OF_WEEK, (i%7) + Calendar.SUNDAY);\r
 640                 if (!testCal.getTime().equals(save)) {\r
 641                     logln("  Parse failed: " + testCal.getTime());\r
 642                     fail= true;\r
 643                 }\r
 644 \r
 645                 testCal.setTime(save);\r
 646                 testCal.add(Calendar.DAY_OF_MONTH, 1);\r
 647             }\r
 648         }\r
 649 \r
 650         Date d[] = new Date[8];\r
 651         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 652         tempcal.clear();\r
 653         tempcal.set(1997, Calendar.DECEMBER, 28);\r
 654         d[0] = tempcal.getTime();\r
 655         tempcal.set(1998, Calendar.JANUARY, 10);\r
 656         d[1] = tempcal.getTime();\r
 657         tempcal.set(1998, Calendar.DECEMBER, 31);\r
 658         d[2] = tempcal.getTime();\r
 659         tempcal.set(1999, Calendar.JANUARY, 1);\r
 660         d[3] = tempcal.getTime();\r
 661         // Test field disambiguation with a few special hard-coded cases.\r
 662         // This shouldn't fail if the above cases aren't failing.\r
 663         Object[] DISAM = {\r
 664             new Integer(1998), new Integer(1), new Integer(Calendar.SUNDAY),\r
 665                 d[0],\r
 666             new Integer(1998), new Integer(2), new Integer(Calendar.SATURDAY),\r
 667                 d[1],\r
 668             new Integer(1998), new Integer(53), new Integer(Calendar.THURSDAY),\r
 669                 d[2],\r
 670             new Integer(1998), new Integer(53), new Integer(Calendar.FRIDAY),\r
 671                 d[3],\r
 672         };\r
 673         testCal.setMinimalDaysInFirstWeek(3);\r
 674         testCal.setFirstDayOfWeek(Calendar.SUNDAY);\r
 675         for (int i=0; i<DISAM.length; i+=4) {\r
 676             int y = ((Integer)DISAM[i]).intValue();\r
 677             int woy = ((Integer)DISAM[i+1]).intValue();\r
 678             int dow = ((Integer)DISAM[i+2]).intValue();\r
 679             Date exp = (Date)DISAM[i+3];\r
 680             testCal.clear();\r
 681             testCal.set(Calendar.YEAR, y);\r
 682             testCal.set(Calendar.WEEK_OF_YEAR, woy);\r
 683             testCal.set(Calendar.DAY_OF_WEEK, dow);\r
 684             log(y + "-W" + woy +\r
 685                              "-DOW" + dow + " expect:" + exp +\r
 686                              " got:" + testCal.getTime());\r
 687             if (!testCal.getTime().equals(exp)) {\r
 688                 log("  FAIL");\r
 689                 fail = true;\r
 690             }\r
 691             //logln();\r
 692         }\r
 693 \r
 694         // Now try adding and rolling\r
 695         Object ADD = new Object();\r
 696         Object ROLL = new Object();\r
 697         tempcal.set(1998, Calendar.DECEMBER, 25);\r
 698         d[0] = tempcal.getTime();\r
 699         tempcal.set(1999, Calendar.JANUARY, 1);\r
 700         d[1] = tempcal.getTime();\r
 701         tempcal.set(1997, Calendar.DECEMBER, 28);\r
 702         d[2] = tempcal.getTime();\r
 703         tempcal.set(1998, Calendar.JANUARY, 4);\r
 704         d[3] = tempcal.getTime();\r
 705         tempcal.set(1998, Calendar.DECEMBER, 27);\r
 706         d[4] = tempcal.getTime();\r
 707         tempcal.set(1997, Calendar.DECEMBER, 28);\r
 708         d[5] = tempcal.getTime();\r
 709         tempcal.set(1999, Calendar.JANUARY, 2);\r
 710         d[6] = tempcal.getTime();\r
 711         tempcal.set(1998, Calendar.JANUARY, 3);\r
 712         d[7] = tempcal.getTime();\r
 713         \r
 714         Object[] ADDROLL = {\r
 715             ADD, new Integer(1), d[0], d[1],\r
 716             ADD, new Integer(1), d[2], d[3],\r
 717             ROLL, new Integer(1), d[4], d[5],\r
 718             ROLL, new Integer(1), d[6], d[7],\r
 719         };\r
 720         testCal.setMinimalDaysInFirstWeek(3);\r
 721         testCal.setFirstDayOfWeek(Calendar.SUNDAY);\r
 722         for (int i=0; i<ADDROLL.length; i+=4) {\r
 723             int amount = ((Integer)ADDROLL[i+1]).intValue();\r
 724             Date before = (Date)ADDROLL[i+2];\r
 725             Date after = (Date)ADDROLL[i+3];\r
 726 \r
 727             testCal.setTime(before);\r
 728             if (ADDROLL[i] == ADD) testCal.add(Calendar.WEEK_OF_YEAR, amount);\r
 729             else testCal.roll(Calendar.WEEK_OF_YEAR, amount);\r
 730             log((ADDROLL[i]==ADD?"add(WOY,":"roll(WOY,") +\r
 731                              amount + ") " + before + " => " +\r
 732                              testCal.getTime());\r
 733             if (!after.equals(testCal.getTime())) {\r
 734                 logln("  exp:" + after + "  FAIL");\r
 735                 fail = true;\r
 736             }\r
 737             else logln(" ok");\r
 738 \r
 739             testCal.setTime(after);\r
 740             if (ADDROLL[i] == ADD) testCal.add(Calendar.WEEK_OF_YEAR, -amount);\r
 741             else testCal.roll(Calendar.WEEK_OF_YEAR, -amount);\r
 742             log((ADDROLL[i]==ADD?"add(WOY,":"roll(WOY,") +\r
 743                              (-amount) + ") " + after + " => " +\r
 744                              testCal.getTime());\r
 745             if (!before.equals(testCal.getTime())) {\r
 746                 logln("  exp:" + before + "  FAIL");\r
 747                 fail = true;\r
 748             }\r
 749             else logln(" ok");\r
 750         }\r
 751 \r
 752         if (fail) errln("Fail: Week of year misbehaving");\r
 753     } \r
 754 \r
 755     public void Test4106136() {\r
 756         Locale saveLocale = Locale.getDefault();\r
 757         String[] names = { "Calendar", "DateFormat", "NumberFormat" };\r
 758         try {\r
 759             Locale[] locales = { Locale.CHINESE, Locale.CHINA };\r
 760             for (int i=0; i<locales.length; ++i) {\r
 761                 Locale.setDefault(locales[i]);\r
 762                 int[] n = {\r
 763                     Calendar.getAvailableLocales().length,\r
 764                     DateFormat.getAvailableLocales().length,\r
 765                     NumberFormat.getAvailableLocales().length\r
 766                 };\r
 767                 for (int j=0; j<n.length; ++j) {\r
 768                     if (n[j] == 0)\r
 769                         errln("Fail: " + names[j] + " has no locales for " + locales[i]);\r
 770                 }\r
 771             }\r
 772         }\r
 773         finally {\r
 774             Locale.setDefault(saveLocale);\r
 775         }\r
 776     }\r
 777 \r
 778     public void Test4108764() {\r
 779         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 780         tempcal.clear();\r
 781         tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 00, 00);\r
 782         Date d00 = tempcal.getTime();\r
 783         tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 00, 56);\r
 784         Date d01 = tempcal.getTime();\r
 785         tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 34, 00);\r
 786         Date d10 = tempcal.getTime();\r
 787         tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 34, 56);\r
 788         Date d11 = tempcal.getTime();\r
 789         tempcal.set(1997, Calendar.JANUARY, 15, 12, 34, 56);\r
 790         Date dM  = tempcal.getTime();\r
 791         tempcal.clear();\r
 792         tempcal.set(1970, Calendar.JANUARY, 1);\r
 793         Date epoch = tempcal.getTime();\r
 794 \r
 795         Calendar cal = Calendar.getInstance(); \r
 796         cal.setTime(d11);\r
 797 \r
 798         cal.clear( Calendar.MINUTE ); \r
 799         logln(cal.getTime().toString()); \r
 800         if (!cal.getTime().equals(d01)) {\r
 801             errln("Fail: " + d11 + " clear(MINUTE) => expect " +\r
 802                   d01 + ", got " + cal.getTime());\r
 803         }\r
 804 \r
 805         cal.set( Calendar.SECOND, 0 ); \r
 806         logln(cal.getTime().toString()); \r
 807         if (!cal.getTime().equals(d00))\r
 808             errln("Fail: set(SECOND, 0) broken");\r
 809 \r
 810         cal.setTime(d11);\r
 811         cal.set( Calendar.SECOND, 0 ); \r
 812         logln(cal.getTime().toString()); \r
 813         if (!cal.getTime().equals(d10))\r
 814             errln("Fail: set(SECOND, 0) broken #2");\r
 815 \r
 816         cal.clear( Calendar.MINUTE ); \r
 817         logln(cal.getTime().toString()); \r
 818         if (!cal.getTime().equals(d00))\r
 819             errln("Fail: clear(MINUTE) broken #2");\r
 820 \r
 821         cal.clear();\r
 822         logln(cal.getTime().toString());\r
 823         if (!cal.getTime().equals(epoch))\r
 824             errln("Fail: after clear() expect " + epoch + ", got " + cal.getTime());\r
 825 \r
 826         cal.setTime(d11);\r
 827         cal.clear( Calendar.MONTH ); \r
 828         logln(cal.getTime().toString()); \r
 829         if (!cal.getTime().equals(dM)) {\r
 830             errln("Fail: " + d11 + " clear(MONTH) => expect " +\r
 831                   dM + ", got " + cal.getTime());\r
 832         }\r
 833     }\r
 834 \r
 835     public void Test4114578() {\r
 836         int ONE_HOUR = 60*60*1000;\r
 837         Calendar cal = Calendar.getInstance();\r
 838         cal.setTimeZone(TimeZone.getTimeZone("PST"));\r
 839         \r
 840         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 841         tempcal.clear();\r
 842         tempcal.set(1998, Calendar.APRIL, 5, 1, 0);\r
 843         long onset = tempcal.getTime().getTime() + ONE_HOUR;\r
 844         tempcal.set(1998, Calendar.OCTOBER, 25, 0, 0);\r
 845         long cease = tempcal.getTime().getTime() + 2*ONE_HOUR;\r
 846 \r
 847         boolean fail = false;\r
 848         \r
 849         final int ADD = 1;\r
 850         final int ROLL = 2;\r
 851 \r
 852         long[] DATA = {\r
 853             // Start Action Amt Expected_change\r
 854             onset - ONE_HOUR,   ADD,      1,     ONE_HOUR,\r
 855             onset,              ADD,     -1,    -ONE_HOUR,\r
 856             onset - ONE_HOUR,   ROLL,     1,     ONE_HOUR,\r
 857             onset,              ROLL,    -1,    -ONE_HOUR,\r
 858             cease - ONE_HOUR,   ADD,      1,     ONE_HOUR,\r
 859             cease,              ADD,     -1,    -ONE_HOUR,\r
 860             cease - ONE_HOUR,   ROLL,     1,     ONE_HOUR,\r
 861             cease,              ROLL,    -1,    -ONE_HOUR,\r
 862         };\r
 863 \r
 864         for (int i=0; i<DATA.length; i+=4) {\r
 865             Date date = new Date(DATA[i]);\r
 866             int amt = (int) DATA[i+2];\r
 867             long expectedChange = DATA[i+3];\r
 868             \r
 869             log(date.toString());\r
 870             cal.setTime(date);\r
 871 \r
 872             switch ((int) DATA[i+1]) {\r
 873             case ADD:\r
 874                 log(" add (HOUR," + (amt<0?"":"+")+amt + ")= ");\r
 875                 cal.add(Calendar.HOUR, amt);\r
 876                 break;\r
 877             case ROLL:\r
 878                 log(" roll(HOUR," + (amt<0?"":"+")+amt + ")= ");\r
 879                 cal.roll(Calendar.HOUR, amt);\r
 880                 break;\r
 881             }\r
 882 \r
 883             log(cal.getTime().toString());\r
 884 \r
 885             long change = cal.getTime().getTime() - date.getTime();\r
 886             if (change != expectedChange) {\r
 887                 fail = true;\r
 888                 logln(" FAIL");\r
 889             }\r
 890             else logln(" OK");\r
 891         }\r
 892 \r
 893         if (fail) errln("Fail: roll/add misbehaves around DST onset/cease");\r
 894     }\r
 895 \r
 896     /**\r
 897      * Make sure maximum for HOUR field is 11, not 12.\r
 898      */\r
 899     public void Test4118384() {\r
 900         Calendar cal = Calendar.getInstance();\r
 901         if (cal.getMaximum(Calendar.HOUR) != 11 ||\r
 902             cal.getLeastMaximum(Calendar.HOUR) != 11 ||\r
 903             cal.getActualMaximum(Calendar.HOUR) != 11)\r
 904             errln("Fail: maximum of HOUR field should be 11");\r
 905     }\r
 906 \r
 907     /**\r
 908      * Check isLeapYear for BC years.\r
 909      */\r
 910     public void Test4125881() {\r
 911         GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();\r
 912         DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");\r
 913         cal.clear();\r
 914         for (int y=-20; y<=10; ++y) {\r
 915             cal.set(Calendar.ERA, y < 1 ? GregorianCalendar.BC : GregorianCalendar.AD);\r
 916             cal.set(Calendar.YEAR, y < 1 ? 1 - y : y);\r
 917             logln(y + " = " + fmt.format(cal.getTime()) + " " +\r
 918                                cal.isLeapYear(y));\r
 919             if (cal.isLeapYear(y) != ((y+40)%4 == 0))\r
 920                 errln("Leap years broken");\r
 921         }\r
 922     }\r
 923 \r
 924     // I am disabling this test -- it is currently failing because of a bug\r
 925     // in Sun's latest change to STZ.getOffset(). I have filed a Sun bug\r
 926     // against this problem.\r
 927 \r
 928     // Re-enabled after 'porting' TZ and STZ from java.util to com.ibm.icu.util.\r
 929     /**\r
 930      * Prove that GregorianCalendar is proleptic (it used to cut off at 45 BC,\r
 931      * and not have leap years before then).\r
 932      */\r
 933     public void Test4125892() {\r
 934         GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();\r
 935         //DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");\r
 936         //fmt = null;\r
 937         cal.clear();\r
 938         cal.set(Calendar.ERA, GregorianCalendar.BC);\r
 939         cal.set(Calendar.YEAR, 81); // 81 BC is a leap year (proleptically)\r
 940         cal.set(Calendar.MONTH, Calendar.FEBRUARY);\r
 941         cal.set(Calendar.DATE, 28);\r
 942         cal.add(Calendar.DATE, 1);\r
 943         if (cal.get(Calendar.DATE) != 29 ||\r
 944             !cal.isLeapYear(-80)) // -80 == 81 BC\r
 945             errln("Calendar not proleptic");\r
 946     }\r
 947 \r
 948     /**\r
 949      * Calendar and GregorianCalendar hashCode() methods need improvement.\r
 950      * Calendar needs a good implementation that subclasses can override, and\r
 951      * GregorianCalendar should use that implementation.\r
 952      */\r
 953     public void Test4136399() {\r
 954         /*\r
 955          * Note: This test is actually more strict than it has to be.\r
 956          * Technically, there is no requirement that unequal objects have\r
 957          * unequal hashes. We only require equal objects to have equal hashes.\r
 958          * It is desirable for unequal objects to have distributed hashes, but\r
 959          * there is no hard requirement here.\r
 960          * \r
 961          * In this test we make assumptions about certain attributes of calendar\r
 962          * objects getting represented in the hash, which need not always be the\r
 963          * case (although it does work currently with the given test).\r
 964          */\r
 965         Calendar a = Calendar.getInstance();\r
 966         Calendar b = (Calendar)a.clone();\r
 967         if (a.hashCode() != b.hashCode()) {\r
 968             errln("Calendar hash code unequal for cloned objects");\r
 969         }\r
 970         TimeZone atz1 = a.getTimeZone();\r
 971         TimeZone atz2 = (TimeZone)atz1.clone();\r
 972         if(!atz1.equals(atz2)){\r
 973             errln("The clone timezones are not equal");\r
 974         }\r
 975         if(atz1.hashCode()!=atz2.hashCode()){\r
 976             errln("TimeZone hash code unequal for cloned objects");\r
 977         }\r
 978         b.setMinimalDaysInFirstWeek(7 - a.getMinimalDaysInFirstWeek());\r
 979         if (a.hashCode() == b.hashCode()) {\r
 980             errln("Calendar hash code ignores minimal days in first week");\r
 981         }\r
 982         b.setMinimalDaysInFirstWeek(a.getMinimalDaysInFirstWeek());\r
 983 \r
 984         b.setFirstDayOfWeek((a.getFirstDayOfWeek() % 7) + 1); // Next day\r
 985         if (a.hashCode() == b.hashCode()) {\r
 986             errln("Calendar hash code ignores first day of week");\r
 987         }\r
 988         b.setFirstDayOfWeek(a.getFirstDayOfWeek());\r
 989 \r
 990         b.setLenient(!a.isLenient());\r
 991         if (a.hashCode() == b.hashCode()) {\r
 992             errln("Calendar hash code ignores lenient setting");\r
 993         }\r
 994         b.setLenient(a.isLenient());\r
 995         \r
 996         // Assume getTimeZone() returns a reference, not a clone\r
 997         // of a reference -- this is true as of this writing\r
 998         TimeZone atz = a.getTimeZone();\r
 999         TimeZone btz = b.getTimeZone();\r
1000 \r
1001         btz.setRawOffset(atz.getRawOffset() + 60*60*1000);\r
1002         if(atz.hashCode()== btz.hashCode()){\r
1003             errln(atz.hashCode()+"=="+btz.hashCode());\r
1004         }\r
1005         if (a.getTimeZone()!= b.getTimeZone() && a.hashCode() == b.hashCode()) {\r
1006             errln("Calendar hash code ignores zone");\r
1007         }\r
1008         b.getTimeZone().setRawOffset(a.getTimeZone().getRawOffset());\r
1009 \r
1010         GregorianCalendar c = new GregorianCalendar();\r
1011         GregorianCalendar d = (GregorianCalendar)c.clone();\r
1012         if (c.hashCode() != d.hashCode()) {\r
1013             errln("GregorianCalendar hash code unequal for clones objects");\r
1014         }\r
1015         Date cutover = c.getGregorianChange();\r
1016         d.setGregorianChange(new Date(cutover.getTime() + 24*60*60*1000));\r
1017         if (c.hashCode() == d.hashCode()) {\r
1018             errln("GregorianCalendar hash code ignores cutover");\r
1019         }        \r
1020     }\r
1021 \r
1022     /**\r
1023      * GregorianCalendar.equals() ignores cutover date\r
1024      */\r
1025     public void Test4141665() {\r
1026         GregorianCalendar cal = new GregorianCalendar();\r
1027         GregorianCalendar cal2 = (GregorianCalendar)cal.clone();\r
1028         Date cut = cal.getGregorianChange();\r
1029         Date cut2 = new Date(cut.getTime() + 100*24*60*60*1000L); // 100 days\r
1030                                                                   // later\r
1031         if (!cal.equals(cal2)) {\r
1032             errln("Cloned GregorianCalendars not equal");\r
1033         }\r
1034         cal2.setGregorianChange(cut2);\r
1035         if (cal.equals(cal2)) {\r
1036             errln("GregorianCalendar.equals() ignores cutover");\r
1037         }\r
1038     }\r
1039     \r
1040     /**\r
1041      * Bug states that ArrayIndexOutOfBoundsException is thrown by\r
1042      * GregorianCalendar.roll() when IllegalArgumentException should be.\r
1043      */\r
1044     public void Test4142933() {\r
1045         GregorianCalendar calendar = new GregorianCalendar();\r
1046         try {\r
1047             calendar.roll(-1, true);\r
1048             errln("Test failed, no exception trown");\r
1049         }\r
1050         catch (IllegalArgumentException e) {\r
1051             // OK: Do nothing\r
1052             // logln("Test passed");\r
1053             System.out.print("");\r
1054         }\r
1055         catch (Exception e) {\r
1056             errln("Test failed. Unexpected exception is thrown: " + e);\r
1057             e.printStackTrace();\r
1058         } \r
1059     }\r
1060 \r
1061     /**\r
1062      * GregorianCalendar handling of Dates Long.MIN_VALUE and Long.MAX_VALUE is\r
1063      * confusing; unless the time zone has a raw offset of zero, one or the\r
1064      * other of these will wrap. We've modified the test given in the bug report\r
1065      * to therefore only check the behavior of a calendar with a zero raw offset\r
1066      * zone.\r
1067      */\r
1068     public void Test4145158() {\r
1069         GregorianCalendar calendar = new GregorianCalendar();\r
1070 \r
1071         calendar.setTimeZone(TimeZone.getTimeZone("GMT"));\r
1072 \r
1073         calendar.setTime(new Date(Long.MIN_VALUE));\r
1074         int year1 = calendar.get(Calendar.YEAR);\r
1075         int era1 = calendar.get(Calendar.ERA);\r
1076         \r
1077         calendar.setTime(new Date(Long.MAX_VALUE));\r
1078         int year2 = calendar.get(Calendar.YEAR);\r
1079         int era2 = calendar.get(Calendar.ERA);\r
1080         \r
1081         if (year1 == year2 && era1 == era2) {\r
1082             errln("Fail: Long.MIN_VALUE or Long.MAX_VALUE wrapping around");\r
1083         }\r
1084     }\r
1085 \r
1086     /**\r
1087      * Maximum value for YEAR field wrong.\r
1088      */\r
1089     public void Test4145983() {\r
1090         GregorianCalendar calendar = new GregorianCalendar();\r
1091         calendar.setTimeZone(TimeZone.getTimeZone("GMT"));\r
1092         Date[] DATES = { new Date(Long.MAX_VALUE), new Date(Long.MIN_VALUE) };\r
1093         for (int i=0; i<DATES.length; ++i) {\r
1094             calendar.setTime(DATES[i]);\r
1095             int year = calendar.get(Calendar.YEAR);\r
1096             int maxYear = calendar.getMaximum(Calendar.YEAR);\r
1097             if (year > maxYear) {\r
1098                 errln("Failed for "+DATES[i].getTime()+" ms: year=" +\r
1099                       year + ", maxYear=" + maxYear);\r
1100             }\r
1101         }\r
1102     }\r
1103 \r
1104     /**\r
1105      * This is a bug in the validation code of GregorianCalendar. As reported,\r
1106      * the bug seems worse than it really is, due to a bug in the way the bug\r
1107      * report test was written. In reality the bug is restricted to the\r
1108      * DAY_OF_YEAR field. - liu 6/29/98\r
1109      */\r
1110     public void Test4147269() {\r
1111         GregorianCalendar calendar = new GregorianCalendar();\r
1112         calendar.setLenient(false);\r
1113         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
1114         tempcal.clear();\r
1115         tempcal.set(1996, Calendar.JANUARY, 3); // Arbitrary date\r
1116         Date date = tempcal.getTime(); \r
1117         for (int field = 0; field < calendar.getFieldCount(); field++) {\r
1118             calendar.setTime(date);\r
1119             // Note: In the bug report, getActualMaximum() was called instead\r
1120             // of getMaximum() -- this was an error. The validation code doesn't\r
1121             // use getActualMaximum(), since that's too costly.\r
1122             int max = calendar.getMaximum(field);\r
1123             int value = max+1;\r
1124             calendar.set(field, value); \r
1125             try {\r
1126                 calendar.getTime(); // Force time computation\r
1127                 // We expect an exception to be thrown. If we fall through\r
1128                 // to the next line, then we have a bug.\r
1129                 errln("Test failed with field " + FIELD_NAME[field] +\r
1130                       ", date before: " + date +\r
1131                       ", date after: " + calendar.getTime() +\r
1132                       ", value: " + value + " (max = " + max +")");\r
1133             } catch (IllegalArgumentException e) {\r
1134                 System.out.print("");\r
1135             } \r
1136         }\r
1137     }\r
1138 \r
1139     /**\r
1140      * Reported bug is that a GregorianCalendar with a cutover of\r
1141      * Date(Long.MAX_VALUE) doesn't behave as a pure Julian calendar. CANNOT\r
1142      * REPRODUCE THIS BUG\r
1143      */\r
1144     public void Test4149677() {\r
1145         TimeZone[] zones = { TimeZone.getTimeZone("GMT"),\r
1146                              TimeZone.getTimeZone("PST"),\r
1147                              TimeZone.getTimeZone("EAT") };\r
1148         for (int i=0; i<zones.length; ++i) {\r
1149             GregorianCalendar calendar = new GregorianCalendar(zones[i]);\r
1150 \r
1151             // Make sure extreme values don't wrap around\r
1152             calendar.setTime(new Date(Long.MIN_VALUE));\r
1153             if (calendar.get(Calendar.ERA) != GregorianCalendar.BC) {\r
1154                 errln("Fail: Long.MIN_VALUE ms has an AD year");\r
1155             }\r
1156             calendar.setTime(new Date(Long.MAX_VALUE));\r
1157             if (calendar.get(Calendar.ERA) != GregorianCalendar.AD) {\r
1158                 errln("Fail: Long.MAX_VALUE ms has a BC year");\r
1159             }\r
1160 \r
1161             calendar.setGregorianChange(new Date(Long.MAX_VALUE));\r
1162             // to obtain a pure Julian calendar\r
1163             \r
1164             boolean is100Leap = calendar.isLeapYear(100);\r
1165             if (!is100Leap) {\r
1166                 errln("test failed with zone " + zones[i].getID());\r
1167                 errln(" cutover date is Calendar.MAX_DATE");\r
1168                 errln(" isLeapYear(100) returns: " + is100Leap);\r
1169             }\r
1170         }\r
1171     }\r
1172 \r
1173     /**\r
1174      * Calendar and Date HOUR broken. If HOUR is out-of-range, Calendar and Date\r
1175      * classes will misbehave.\r
1176      */\r
1177     public void Test4162587() {\r
1178         TimeZone tz = TimeZone.getTimeZone("PST");\r
1179         TimeZone.setDefault(tz);\r
1180         GregorianCalendar cal = new GregorianCalendar(tz);\r
1181         Date d;\r
1182         \r
1183         for (int i=0; i<5; ++i) {\r
1184             if (i>0) logln("---");\r
1185 \r
1186             cal.clear();\r
1187             cal.set(1998, Calendar.APRIL, 5, i, 0);\r
1188             d = cal.getTime();\r
1189             String s0 = d.toString();\r
1190             logln("0 " + i + ": " + s0);\r
1191 \r
1192             cal.clear();\r
1193             cal.set(1998, Calendar.APRIL, 4, i+24, 0);\r
1194             d = cal.getTime();\r
1195             String sPlus = d.toString();\r
1196             logln("+ " + i + ": " + sPlus);\r
1197 \r
1198             cal.clear();\r
1199             cal.set(1998, Calendar.APRIL, 6, i-24, 0);\r
1200             d = cal.getTime();\r
1201             String sMinus = d.toString();\r
1202             logln("- " + i + ": " + sMinus);\r
1203 \r
1204             if (!s0.equals(sPlus) || !s0.equals(sMinus)) {\r
1205                 errln("Fail: All three lines must match");\r
1206             }\r
1207         }\r
1208     }\r
1209 \r
1210     /**\r
1211      * Adding 12 months behaves differently from adding 1 year\r
1212      */\r
1213     public void Test4165343() {\r
1214         GregorianCalendar calendar = new GregorianCalendar(1996, Calendar.FEBRUARY, 29);\r
1215         Date start = calendar.getTime();\r
1216         logln("init date: " + start);\r
1217         calendar.add(Calendar.MONTH, 12); \r
1218         Date date1 = calendar.getTime();\r
1219         logln("after adding 12 months: " + date1);\r
1220         calendar.setTime(start);\r
1221         calendar.add(Calendar.YEAR, 1);\r
1222         Date date2 = calendar.getTime();\r
1223         logln("after adding one year : " + date2);\r
1224         if (date1.equals(date2)) {\r
1225             logln("Test passed");\r
1226         } else {\r
1227             errln("Test failed");\r
1228         }\r
1229     }\r
1230 \r
1231     /**\r
1232      * GregorianCalendar.getActualMaximum() does not account for first day of\r
1233      * week.\r
1234      */\r
1235     public void Test4166109() {\r
1236         /*\r
1237          * Test month:\r
1238          * \r
1239          * March 1998 Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15\r
1240          * 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31\r
1241          */\r
1242         boolean passed = true;\r
1243         int field = Calendar.WEEK_OF_MONTH;\r
1244 \r
1245         GregorianCalendar calendar = new GregorianCalendar(Locale.US);\r
1246         calendar.set(1998, Calendar.MARCH, 1);\r
1247         calendar.setMinimalDaysInFirstWeek(1);\r
1248         logln("Date:  " + calendar.getTime());\r
1249 \r
1250         int firstInMonth = calendar.get(Calendar.DAY_OF_MONTH);\r
1251 \r
1252         for (int firstInWeek = Calendar.SUNDAY; firstInWeek <= Calendar.SATURDAY; firstInWeek++) {\r
1253             calendar.setFirstDayOfWeek(firstInWeek);\r
1254             int returned = calendar.getActualMaximum(field);\r
1255             int expected = (31 + ((firstInMonth - firstInWeek + 7)% 7) + 6) / 7;\r
1256 \r
1257             logln("First day of week = " + firstInWeek +\r
1258                   "  getActualMaximum(WEEK_OF_MONTH) = " + returned +\r
1259                   "  expected = " + expected +\r
1260                   ((returned == expected) ? "  ok" : "  FAIL"));\r
1261 \r
1262             if (returned != expected) {\r
1263                 passed = false;\r
1264             }\r
1265         }\r
1266         if (!passed) {\r
1267             errln("Test failed");\r
1268         }\r
1269     }\r
1270 \r
1271     /**\r
1272      * Calendar.getActualMaximum(YEAR) works wrong.\r
1273      */\r
1274     public void Test4167060() {\r
1275         int field = Calendar.YEAR;\r
1276         DateFormat format = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy G",\r
1277                                                  Locale.US);\r
1278 \r
1279         GregorianCalendar calendars[] = {\r
1280             new GregorianCalendar(100, Calendar.NOVEMBER, 1),\r
1281             new GregorianCalendar(-99 /* 100BC */, Calendar.JANUARY, 1),\r
1282             new GregorianCalendar(1996, Calendar.FEBRUARY, 29),\r
1283         };\r
1284 \r
1285         String[] id = { "Hybrid", "Gregorian", "Julian" };\r
1286 \r
1287         for (int k=0; k<3; ++k) {\r
1288             logln("--- " + id[k] + " ---");\r
1289 \r
1290             for (int j=0; j<calendars.length; ++j) {\r
1291                 GregorianCalendar calendar = calendars[j];\r
1292                 if (k == 1) {\r
1293                     calendar.setGregorianChange(new Date(Long.MIN_VALUE));\r
1294                 } else if (k == 2) {\r
1295                     calendar.setGregorianChange(new Date(Long.MAX_VALUE));\r
1296                 }\r
1297 \r
1298                 format.setCalendar((Calendar)calendar.clone());\r
1299 \r
1300                 Date dateBefore = calendar.getTime();\r
1301 \r
1302                 int maxYear = calendar.getActualMaximum(field);\r
1303                 logln("maxYear: " + maxYear + " for " + format.format(calendar.getTime()));\r
1304                 logln("date before: " + format.format(dateBefore));\r
1305 \r
1306                 int years[] = {2000, maxYear-1, maxYear, maxYear+1};\r
1307 \r
1308                 for (int i = 0; i < years.length; i++) {\r
1309                     boolean valid = years[i] <= maxYear;\r
1310                     calendar.set(field, years[i]);\r
1311                     Date dateAfter = calendar.getTime();\r
1312                     int newYear = calendar.get(field);\r
1313                     calendar.setTime(dateBefore); // restore calendar for next\r
1314                                                   // use\r
1315 \r
1316                     logln(" Year " + years[i] + (valid? " ok " : " bad") +\r
1317                           " => " + format.format(dateAfter));\r
1318                     if (valid && newYear != years[i]) {\r
1319                         errln("  FAIL: " + newYear + " should be valid; date, month and time shouldn't change");\r
1320                     } else if (!valid && newYear == years[i]) {\r
1321                         // We no longer require strict year maxima. That is, the\r
1322                         // calendar\r
1323                         // algorithm may work for values > the stated maximum.\r
1324                         //errln(" FAIL: " + newYear + " should be invalid");\r
1325                         logln("  Note: " + newYear + " > maximum, but still valid");\r
1326                     }\r
1327                 }\r
1328             }\r
1329         }\r
1330     }\r
1331 \r
1332     /**\r
1333      * Calendar.roll broken This bug relies on the TimeZone bug 4173604 to also\r
1334      * be fixed.\r
1335      */\r
1336     public void Test4173516() {\r
1337         int fieldsList[][] = {\r
1338             { 1997, Calendar.FEBRUARY,  1, 10, 45, 15, 900 },\r
1339             { 1999, Calendar.DECEMBER, 22, 23, 59, 59, 999 }\r
1340         };\r
1341         int limit = 40;\r
1342         GregorianCalendar cal = new GregorianCalendar();\r
1343 \r
1344         cal.setTime(new Date(0));\r
1345         cal.roll(Calendar.HOUR,  0x7F000000);\r
1346         cal.roll(Calendar.HOUR, -0x7F000000);\r
1347         if (cal.getTime().getTime() != 0) {\r
1348             errln("Hour rolling broken");\r
1349         }\r
1350 \r
1351         for (int op=0; op<2; ++op) {\r
1352             logln("Testing GregorianCalendar " +\r
1353                   (op==0 ? "add" : "roll"));\r
1354             for (int field=0; field < cal.getFieldCount(); ++field) {\r
1355                 if (field != Calendar.ZONE_OFFSET &&\r
1356                     field != Calendar.DST_OFFSET &&\r
1357                     field != Calendar.IS_LEAP_MONTH ) {\r
1358                     for (int j=0; j<fieldsList.length; ++j) {\r
1359                         int fields[] = fieldsList[j];\r
1360                         cal.clear();\r
1361                         cal.set(fields[0], fields[1], fields[2],\r
1362                                 fields[3], fields[4], fields[5]);\r
1363                         cal.set(Calendar.MILLISECOND, fields[6]);\r
1364                         cal.setMinimalDaysInFirstWeek(1);\r
1365                         for (int i = 0; i < 2*limit; i++) {\r
1366                             if (op == 0) {\r
1367                                 cal.add(field, i < limit ? 1 : -1);\r
1368                             } else {\r
1369                                 cal.roll(field, i < limit ? 1 : -1);\r
1370                             }\r
1371                         }\r
1372                         if (cal.get(Calendar.YEAR) != fields[0] ||\r
1373                             cal.get(Calendar.MONTH) != fields[1] ||\r
1374                             cal.get(Calendar.DATE) != fields[2] ||\r
1375                             cal.get(Calendar.HOUR_OF_DAY) != fields[3] ||\r
1376                             cal.get(Calendar.MINUTE) != fields[4] ||\r
1377                             cal.get(Calendar.SECOND) != fields[5] ||\r
1378                             cal.get(Calendar.MILLISECOND) != fields[6]) {\r
1379                             errln("Field " + field +\r
1380                                   " (" + FIELD_NAME[field] +\r
1381                                   ") FAIL, expected " +\r
1382                                   fields[0] +\r
1383                                   "/" + (fields[1] + 1) +\r
1384                                   "/" + fields[2] +\r
1385                                   " " + fields[3] +\r
1386                                   ":" + fields[4] +\r
1387                                   ":" + fields[5] +\r
1388                                   "." + fields[6] +\r
1389                                   ", got " + cal.get(Calendar.YEAR) +\r
1390                                   "/" + (cal.get(Calendar.MONTH) + 1) +\r
1391                                   "/" + cal.get(Calendar.DATE) +\r
1392                                   " " + cal.get(Calendar.HOUR_OF_DAY) +\r
1393                                   ":" + cal.get(Calendar.MINUTE) +\r
1394                                   ":" + cal.get(Calendar.SECOND) +\r
1395                                   "." + cal.get(Calendar.MILLISECOND));\r
1396                             cal.clear();\r
1397                             cal.set(fields[0], fields[1], fields[2],\r
1398                                     fields[3], fields[4], fields[5]);\r
1399                             cal.set(Calendar.MILLISECOND, fields[6]);\r
1400                             logln("Start date: " + cal.get(Calendar.YEAR) +\r
1401                                   "/" + (cal.get(Calendar.MONTH) + 1) +\r
1402                                   "/" + cal.get(Calendar.DATE) +\r
1403                                   " " + cal.get(Calendar.HOUR_OF_DAY) +\r
1404                                   ":" + cal.get(Calendar.MINUTE) +\r
1405                                   ":" + cal.get(Calendar.SECOND) +\r
1406                                   "." + cal.get(Calendar.MILLISECOND));\r
1407                             long prev = cal.getTime().getTime();\r
1408                             for (int i = 0; i < 2*limit; i++) {\r
1409                                 if (op == 0) {\r
1410                                     cal.add(field, i < limit ? 1 : -1);\r
1411                                 } else {\r
1412                                     cal.roll(field, i < limit ? 1 : -1);\r
1413                                 }\r
1414                                 long t = cal.getTime().getTime();\r
1415                                 long delta = t - prev;\r
1416                                 prev = t;\r
1417                                 logln((op == 0 ? "add(" : "roll(") + FIELD_NAME[field] +\r
1418                                       (i < limit ? ", +1) => " : ", -1) => ") +\r
1419                                       cal.get(Calendar.YEAR) +\r
1420                                       "/" + (cal.get(Calendar.MONTH) + 1) +\r
1421                                       "/" + cal.get(Calendar.DATE) +\r
1422                                       " " + cal.get(Calendar.HOUR_OF_DAY) +\r
1423                                       ":" + cal.get(Calendar.MINUTE) +\r
1424                                       ":" + cal.get(Calendar.SECOND) +\r
1425                                       "." + cal.get(Calendar.MILLISECOND) +\r
1426                                       " delta=" + delta + " ms");\r
1427                             }\r
1428                         }\r
1429                     }\r
1430                 }\r
1431             }\r
1432         }\r
1433     }\r
1434 \r
1435     public void Test4174361() {\r
1436         GregorianCalendar calendar = new GregorianCalendar(1996, 1, 29);\r
1437 \r
1438         calendar.add(Calendar.MONTH, 10); \r
1439         //Date date1 = calendar.getTime();\r
1440         //date1 = null;\r
1441         int d1 = calendar.get(Calendar.DAY_OF_MONTH);\r
1442 \r
1443         calendar = new GregorianCalendar(1996, 1, 29);\r
1444         calendar.add(Calendar.MONTH, 11); \r
1445         //Date date2 = calendar.getTime();\r
1446         //date2 = null;\r
1447         int d2 = calendar.get(Calendar.DAY_OF_MONTH);\r
1448 \r
1449         if (d1 != d2) {\r
1450             errln("adding months to Feb 29 broken");\r
1451         }\r
1452     }\r
1453 \r
1454     /**\r
1455      * Calendar does not update field values when setTimeZone is called.\r
1456      */\r
1457     public void Test4177484() {\r
1458         TimeZone PST = TimeZone.getTimeZone("PST");\r
1459         TimeZone EST = TimeZone.getTimeZone("EST");\r
1460 \r
1461         Calendar cal = Calendar.getInstance(PST, Locale.US);\r
1462         cal.clear();\r
1463         cal.set(1999, 3, 21, 15, 5, 0); // Arbitrary\r
1464         int h1 = cal.get(Calendar.HOUR_OF_DAY);\r
1465         cal.setTimeZone(EST);\r
1466         int h2 = cal.get(Calendar.HOUR_OF_DAY);\r
1467         if (h1 == h2) {\r
1468             errln("FAIL: Fields not updated after setTimeZone");\r
1469         }\r
1470 \r
1471         // getTime() must NOT change when time zone is changed.\r
1472         // getTime() returns zone-independent time in ms.\r
1473         cal.clear();\r
1474         cal.setTimeZone(PST);\r
1475         cal.set(Calendar.HOUR_OF_DAY, 10);\r
1476         Date pst10 = cal.getTime();\r
1477         cal.setTimeZone(EST);\r
1478         Date est10 = cal.getTime();\r
1479         if (!pst10.equals(est10)) {\r
1480             errln("FAIL: setTimeZone changed time");\r
1481         }\r
1482     }\r
1483 \r
1484     /**\r
1485      * Week of year is wrong at the start and end of the year.\r
1486      */\r
1487     public void Test4197699() {\r
1488         GregorianCalendar cal = new GregorianCalendar();\r
1489         cal.setFirstDayOfWeek(Calendar.MONDAY);\r
1490         cal.setMinimalDaysInFirstWeek(4);\r
1491         DateFormat fmt = new SimpleDateFormat("E dd MMM yyyy  'DOY='D 'WOY='w");\r
1492         fmt.setCalendar(cal);\r
1493 \r
1494         int[] DATA = {\r
1495             2000,  Calendar.JANUARY,   1,   52,\r
1496             2001,  Calendar.DECEMBER,  31,  1,\r
1497         };\r
1498 \r
1499         for (int i=0; i<DATA.length; ) {\r
1500             cal.set(DATA[i++], DATA[i++], DATA[i++]);\r
1501             int expWOY = DATA[i++];\r
1502             int actWOY = cal.get(Calendar.WEEK_OF_YEAR);\r
1503             if (expWOY == actWOY) {\r
1504                 logln("Ok: " + fmt.format(cal.getTime()));\r
1505             } else {\r
1506                 errln("FAIL: " + fmt.format(cal.getTime())\r
1507                       + ", expected WOY=" + expWOY);\r
1508                 cal.add(Calendar.DATE, -8);\r
1509                 for (int j=0; j<14; ++j) {\r
1510                     cal.add(Calendar.DATE, 1);\r
1511                     logln(fmt.format(cal.getTime()));\r
1512                 }\r
1513             }\r
1514         }\r
1515     }\r
1516 \r
1517     /**\r
1518      * Calendar DAY_OF_WEEK_IN_MONTH fields->time broken. The problem is in the\r
1519      * field disambiguation code in GregorianCalendar. This code is supposed to\r
1520      * choose the most recent set of fields among the following:\r
1521      * \r
1522      * MONTH + DAY_OF_MONTH MONTH + WEEK_OF_MONTH + DAY_OF_WEEK MONTH +\r
1523      * DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK DAY_OF_YEAR WEEK_OF_YEAR + DAY_OF_WEEK\r
1524      */\r
1525     public void Test4209071() {\r
1526         Calendar cal = Calendar.getInstance(Locale.US);\r
1527 \r
1528         // General field setting test\r
1529         int Y = 1995;\r
1530         \r
1531         Date d[] = new Date[13];\r
1532         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
1533         tempcal.clear();\r
1534         tempcal.set(Y, Calendar.JANUARY, 1);\r
1535         d[0] = tempcal.getTime();\r
1536         tempcal.set(Y, Calendar.MARCH, 1);\r
1537         d[1] = tempcal.getTime();\r
1538         tempcal.set(Y, Calendar.JANUARY, 4);\r
1539         d[2] = tempcal.getTime();\r
1540         tempcal.set(Y, Calendar.JANUARY, 18);\r
1541         d[3] = tempcal.getTime();\r
1542         tempcal.set(Y, Calendar.JANUARY, 18);\r
1543         d[4] = tempcal.getTime();\r
1544         tempcal.set(Y-1, Calendar.DECEMBER, 22);\r
1545         d[5] = tempcal.getTime();\r
1546         tempcal.set(Y, Calendar.JANUARY, 26);\r
1547         d[6] = tempcal.getTime();\r
1548         tempcal.set(Y, Calendar.JANUARY, 26);\r
1549         d[7] = tempcal.getTime();\r
1550         tempcal.set(Y, Calendar.MARCH, 1);\r
1551         d[8] = tempcal.getTime();\r
1552         tempcal.set(Y, Calendar.OCTOBER, 6);\r
1553         d[9] = tempcal.getTime();\r
1554         tempcal.set(Y, Calendar.OCTOBER, 13);\r
1555         d[10] = tempcal.getTime();\r
1556         tempcal.set(Y, Calendar.AUGUST, 10);\r
1557         d[11] = tempcal.getTime();\r
1558         tempcal.set(Y, Calendar.DECEMBER, 7);\r
1559         d[12] = tempcal.getTime();\r
1560 \r
1561         Object[] FIELD_DATA = {\r
1562             // Add new test cases as needed.\r
1563 \r
1564             // 0\r
1565             new int[] {}, d[0],\r
1566             // 1\r
1567             new int[] { Calendar.MONTH, Calendar.MARCH }, d[1],\r
1568             // 2\r
1569             new int[] { Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY }, d[2],\r
1570             // 3\r
1571             new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,\r
1572                         Calendar.DAY_OF_MONTH, 18, }, d[3],\r
1573             // 4\r
1574             new int[] { Calendar.DAY_OF_MONTH, 18,\r
1575                         Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[4],\r
1576             // 5 (WOM -1 is in previous month)\r
1577             new int[] { Calendar.DAY_OF_MONTH, 18,\r
1578                         Calendar.WEEK_OF_MONTH, -1,\r
1579                         Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[5],\r
1580             // 6\r
1581             new int[] { Calendar.DAY_OF_MONTH, 18,\r
1582                         Calendar.WEEK_OF_MONTH, 4,\r
1583                         Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[6],\r
1584             // 7 (DIM -1 is in same month)\r
1585             new int[] { Calendar.DAY_OF_MONTH, 18,\r
1586                         Calendar.DAY_OF_WEEK_IN_MONTH, -1,\r
1587                         Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[7],\r
1588             // 8\r
1589             new int[] { Calendar.WEEK_OF_YEAR, 9,\r
1590                         Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY, }, d[8],\r
1591             // 9\r
1592             new int[] { Calendar.MONTH, Calendar.OCTOBER,\r
1593                         Calendar.DAY_OF_WEEK_IN_MONTH, 1,\r
1594                         Calendar.DAY_OF_WEEK, Calendar.FRIDAY, }, d[9],\r
1595             // 10\r
1596             new int[] { Calendar.MONTH, Calendar.OCTOBER,\r
1597                         Calendar.WEEK_OF_MONTH, 2,\r
1598                         Calendar.DAY_OF_WEEK, Calendar.FRIDAY, }, d[10],\r
1599             // 11\r
1600             new int[] { Calendar.MONTH, Calendar.OCTOBER,\r
1601                         Calendar.DAY_OF_MONTH, 15,\r
1602                         Calendar.DAY_OF_YEAR, 222, }, d[11],\r
1603             // 12\r
1604             new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,\r
1605                         Calendar.MONTH, Calendar.DECEMBER, }, d[12],\r
1606         };\r
1607 \r
1608         for (int i=0; i<FIELD_DATA.length; i+=2) {\r
1609             int[] fields = (int[]) FIELD_DATA[i];\r
1610             Date exp = (Date) FIELD_DATA[i+1];\r
1611             \r
1612             cal.clear();\r
1613             cal.set(Calendar.YEAR, Y);\r
1614             for (int j=0; j<fields.length; j+=2) {\r
1615                 cal.set(fields[j], fields[j+1]);\r
1616             }\r
1617             \r
1618             Date act = cal.getTime();\r
1619             if (!act.equals(exp)) {\r
1620                 errln("FAIL: Test " + (i/2) + " got " + act +\r
1621                       ", want " + exp +\r
1622                       " (see test/java/util/Calendar/CalendarRegression.java");\r
1623             }\r
1624         }\r
1625 \r
1626         tempcal.set(1997, Calendar.JANUARY, 5);\r
1627         d[0] = tempcal.getTime();\r
1628         tempcal.set(1997, Calendar.JANUARY, 26);\r
1629         d[1] = tempcal.getTime();\r
1630         tempcal.set(1997, Calendar.FEBRUARY, 23);\r
1631         d[2] = tempcal.getTime();\r
1632         tempcal.set(1997, Calendar.JANUARY, 26);\r
1633         d[3] = tempcal.getTime();\r
1634         tempcal.set(1997, Calendar.JANUARY, 5);\r
1635         d[4] = tempcal.getTime();\r
1636         tempcal.set(1996, Calendar.DECEMBER, 8);\r
1637         d[5] = tempcal.getTime();\r
1638         // Test specific failure reported in bug\r
1639         Object[] DATA = { \r
1640             new Integer(1), d[0], new Integer(4), d[1],\r
1641             new Integer(8), d[2], new Integer(-1), d[3],\r
1642             new Integer(-4), d[4], new Integer(-8), d[5],\r
1643         };\r
1644         for (int i=0; i<DATA.length; i+=2) {\r
1645             cal.clear();\r
1646             cal.set(Calendar.DAY_OF_WEEK_IN_MONTH,\r
1647                     ((Number) DATA[i]).intValue());\r
1648             cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);\r
1649             cal.set(Calendar.MONTH, Calendar.JANUARY);\r
1650             cal.set(Calendar.YEAR, 1997);\r
1651             Date actual = cal.getTime();\r
1652             if (!actual.equals(DATA[i+1])) {\r
1653                 errln("FAIL: Sunday " + DATA[i] +\r
1654                       " of Jan 1997 -> " + actual +\r
1655                       ", want " + DATA[i+1]);\r
1656             }\r
1657         }\r
1658     }\r
1659 \r
1660     /**\r
1661      * WEEK_OF_YEAR computed incorrectly. A failure of this test can indicate a\r
1662      * problem in several different places in the\r
1663      */\r
1664     public void Test4288792() throws Exception \r
1665     {\r
1666     TimeZone savedTZ = TimeZone.getDefault();\r
1667     TimeZone.setDefault(TimeZone.getTimeZone("GMT"));\r
1668     GregorianCalendar cal = new GregorianCalendar();\r
1669         \r
1670     for (int i = 1900; i < 2100; i++) {\r
1671         for (int j1 = 1; j1 <= 7; j1++) {\r
1672         // Loop for MinimalDaysInFirstWeek: 1..7\r
1673         for (int j = Calendar.SUNDAY; j <= Calendar.SATURDAY; j++) {\r
1674             // Loop for FirstDayOfWeek: SUNDAY..SATURDAY\r
1675             cal.clear();\r
1676             cal.setMinimalDaysInFirstWeek(j1);\r
1677             cal.setFirstDayOfWeek(j);\r
1678                     // Set the calendar to the first day of the last week\r
1679                     // of the year. This may overlap some of the start of\r
1680                     // the next year; that is, the last week of 1999 may\r
1681                     // include some of January 2000. Use the add() method\r
1682                     // to advance through the week. For each day, call\r
1683                     // get(WEEK_OF_YEAR). The result should be the same\r
1684                     // for the whole week. Note that a bug in\r
1685                     // getActualMaximum() will break this test.\r
1686             cal.set(Calendar.YEAR, i);\r
1687             int maxWeek = cal.getActualMaximum(Calendar.WEEK_OF_YEAR);\r
1688             cal.set(Calendar.WEEK_OF_YEAR, maxWeek);\r
1689             cal.set(Calendar.DAY_OF_WEEK, j);\r
1690             for (int k = 1; k < 7; k++) {\r
1691             cal.add(Calendar.DATE, 1);\r
1692             int WOY = cal.get(Calendar.WEEK_OF_YEAR);\r
1693             if (WOY != maxWeek) {\r
1694                 errln(cal.getTime() + ",got=" + WOY\r
1695                   + ",expected=" + maxWeek \r
1696                   + ",min=" + j1 + ",first=" + j);\r
1697             }\r
1698             }\r
1699                     // Now advance the calendar one more day. This should\r
1700                     // put it at the first day of week 1 of the next year.\r
1701             cal.add(Calendar.DATE, 1);\r
1702             int WOY = cal.get(Calendar.WEEK_OF_YEAR);\r
1703             if (WOY != 1) {\r
1704             errln(cal.getTime() + ",got=" + WOY \r
1705                   + ",expected=1,min=" + j1 + ",first" + j);\r
1706             }\r
1707         }\r
1708         }\r
1709     }\r
1710     TimeZone.setDefault(savedTZ);\r
1711     }\r
1712 \r
1713     /**\r
1714      * Test fieldDifference().\r
1715      */\r
1716     public void TestJ438() throws Exception {\r
1717         int DATA[] = {\r
1718             2000, Calendar.JANUARY, 20,   2010, Calendar.JUNE, 15,\r
1719             2010, Calendar.JUNE, 15,      2000, Calendar.JANUARY, 20,\r
1720             1964, Calendar.SEPTEMBER, 7,  1999, Calendar.JUNE, 4,\r
1721             1999, Calendar.JUNE, 4,       1964, Calendar.SEPTEMBER, 7,\r
1722         };\r
1723         Calendar cal = Calendar.getInstance(Locale.US);\r
1724         for (int i=0; i<DATA.length; i+=6) {\r
1725             int y1 = DATA[i];\r
1726             int m1 = DATA[i+1];\r
1727             int d1 = DATA[i+2];\r
1728             int y2 = DATA[i+3];\r
1729             int m2 = DATA[i+4];\r
1730             int d2 = DATA[i+5];\r
1731 \r
1732             cal.clear();\r
1733             cal.set(y1, m1, d1);\r
1734             Date date1 = cal.getTime();\r
1735             cal.set(y2, m2, d2);\r
1736             Date date2 = cal.getTime();\r
1737 \r
1738             cal.setTime(date1);\r
1739             int dy = cal.fieldDifference(date2, Calendar.YEAR);\r
1740             int dm = cal.fieldDifference(date2, Calendar.MONTH);\r
1741             int dd = cal.fieldDifference(date2, Calendar.DATE);\r
1742 \r
1743             logln("" + date2 + " - " + date1 + " = " +\r
1744                   dy + "y " + dm + "m " + dd + "d");\r
1745 \r
1746             cal.setTime(date1);\r
1747             cal.add(Calendar.YEAR, dy);\r
1748             cal.add(Calendar.MONTH, dm);\r
1749             cal.add(Calendar.DATE, dd);\r
1750             Date date22 = cal.getTime();\r
1751             if (!date2.equals(date22)) {\r
1752                 errln("FAIL: " + date1 + " + " +\r
1753                       dy + "y " + dm + "m " + dd + "d = " +\r
1754                       date22 + ", exp " + date2);\r
1755             } else {\r
1756                 logln("Ok: " + date1 + " + " +\r
1757                       dy + "y " + dm + "m " + dd + "d = " +\r
1758                       date22);\r
1759             }\r
1760         }\r
1761     }\r
1762     \r
1763     public void TestT5555() throws Exception\r
1764     {\r
1765         Calendar cal = Calendar.getInstance();\r
1766         \r
1767         // Set date to Wednesday, February 21, 2007\r
1768         cal.set(2007, Calendar.FEBRUARY, 21);\r
1769 \r
1770         try {\r
1771             // Advance month by three years\r
1772             cal.add(Calendar.MONTH, 36);\r
1773             \r
1774             // Move to last Wednesday of month.\r
1775             cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, -1);\r
1776             \r
1777             cal.getTime();\r
1778         } catch (Exception e) {\r
1779             errln("Got an exception calling getTime().");\r
1780         }\r
1781         \r
1782         int yy, mm, dd, ee;\r
1783         \r
1784         yy = cal.get(Calendar.YEAR);\r
1785         mm = cal.get(Calendar.MONTH);\r
1786         dd = cal.get(Calendar.DATE);\r
1787         ee = cal.get(Calendar.DAY_OF_WEEK_IN_MONTH);\r
1788         \r
1789         if (yy != 2010 || mm != Calendar.FEBRUARY || dd != 24 || ee != Calendar.WEDNESDAY) {\r
1790             errln("Got date " + yy + "/" + (mm + 1) + "/" + dd + ", expected 2010/2/24");\r
1791         }\r
1792     }\r
1793 \r
1794     /**\r
1795      * Set behavior of DST_OFFSET field. ICU4J Jitterbug 9.\r
1796      */\r
1797     public void TestJ9() {\r
1798         int HOURS = 60*60*1000;\r
1799         Calendar cal = new GregorianCalendar(TimeZone.getTimeZone("PST"),\r
1800                                              Locale.US);\r
1801 \r
1802         final int END_FIELDS = 0x1234;\r
1803 \r
1804         int[] DATA = {\r
1805             // With no explicit ZONE/DST expect 12:00 am\r
1806             Calendar.MONTH, Calendar.JUNE,\r
1807             END_FIELDS,\r
1808             0, 0, // expected hour, min\r
1809 \r
1810             // Normal ZONE/DST for June 1 Pacific is 8:00/1:00\r
1811             Calendar.MONTH, Calendar.JUNE,\r
1812             Calendar.ZONE_OFFSET, -8*HOURS,\r
1813             Calendar.DST_OFFSET, HOURS,\r
1814             END_FIELDS,\r
1815             0, 0, // expected hour, min\r
1816 \r
1817             // With ZONE/DST of 8:00/0:30 expect time of 12:30 am\r
1818             Calendar.MONTH, Calendar.JUNE,\r
1819             Calendar.ZONE_OFFSET, -8*HOURS,\r
1820             Calendar.DST_OFFSET, HOURS/2,\r
1821             END_FIELDS,\r
1822             0, 30, // expected hour, min\r
1823 \r
1824             // With ZONE/DST of 8:00/UNSET expect time of 1:00 am\r
1825             Calendar.MONTH, Calendar.JUNE,\r
1826             Calendar.ZONE_OFFSET, -8*HOURS,\r
1827             END_FIELDS,\r
1828             1, 0, // expected hour, min\r
1829 \r
1830             // With ZONE/DST of UNSET/0:30 expect 4:30 pm (day before)\r
1831             Calendar.MONTH, Calendar.JUNE,\r
1832             Calendar.DST_OFFSET, HOURS/2,\r
1833             END_FIELDS,\r
1834             16, 30, // expected hour, min\r
1835         };\r
1836 \r
1837         for (int i=0; i<DATA.length; ) {\r
1838             int start = i;\r
1839             cal.clear();\r
1840 \r
1841             // Set fields\r
1842             while (DATA[i] != END_FIELDS) {\r
1843                 cal.set(DATA[i++], DATA[i++]);\r
1844             }\r
1845             ++i; // skip over END_FIELDS\r
1846 \r
1847             // Get hour/minute\r
1848             int h = cal.get(Calendar.HOUR_OF_DAY);\r
1849             int m = cal.get(Calendar.MINUTE);\r
1850 \r
1851             // Check\r
1852             if (h != DATA[i] || m != DATA[i+1]) {\r
1853                 errln("Fail: expected " + DATA[i] + ":" + DATA[i+1] +\r
1854                       ", got " + h + ":" + m + " after:");\r
1855                 while (DATA[start] != END_FIELDS) {\r
1856                     logln("set(" + FIELD_NAME[DATA[start++]] +\r
1857                           ", " + DATA[start++] + ");");\r
1858                 }\r
1859             }\r
1860 \r
1861             i += 2; // skip over expected hour, min\r
1862         }\r
1863     }\r
1864 \r
1865     /**\r
1866      * DateFormat class mistakes date style and time style as follows: -\r
1867      * DateFormat.getDateTimeInstance takes date style as time style, and time\r
1868      * style as date style - If a Calendar is passed to\r
1869      * DateFormat.getDateInstance, it returns time instance - If a Calendar is\r
1870      * passed to DateFormat.getTimeInstance, it returns date instance\r
1871      */\r
1872     public void TestDateFormatFactoryJ26() {\r
1873         TimeZone zone = TimeZone.getDefault();\r
1874         try {\r
1875             Locale loc = Locale.US;\r
1876             TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));\r
1877             java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
1878             tempcal.set(2001, Calendar.APRIL, 5, 17, 43, 53);\r
1879             Date date = tempcal.getTime();\r
1880             Calendar cal = Calendar.getInstance(loc);\r
1881             Object[] DATA = {\r
1882                 DateFormat.getDateInstance(DateFormat.SHORT, loc),\r
1883                 "DateFormat.getDateInstance(DateFormat.SHORT, loc)",\r
1884                 "4/5/01",\r
1885 \r
1886                 DateFormat.getTimeInstance(DateFormat.SHORT, loc),\r
1887                 "DateFormat.getTimeInstance(DateFormat.SHORT, loc)",\r
1888                 "5:43 PM",\r
1889 \r
1890                 DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT, loc),\r
1891                 "DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT, loc)",\r
1892                 "Thursday, April 5, 2001 5:43 PM",\r
1893 \r
1894                 DateFormat.getDateInstance(cal, DateFormat.SHORT, loc),\r
1895                 "DateFormat.getDateInstance(cal, DateFormat.SHORT, loc)",\r
1896                 "4/5/01",\r
1897 \r
1898                 DateFormat.getTimeInstance(cal, DateFormat.SHORT, loc),\r
1899                 "DateFormat.getTimeInstance(cal, DateFormat.SHORT, loc)",\r
1900                 "5:43 PM",\r
1901 \r
1902                 DateFormat.getDateTimeInstance(cal, DateFormat.FULL, DateFormat.SHORT, loc),\r
1903                 "DateFormat.getDateTimeInstance(cal, DateFormat.FULL, DateFormat.SHORT, loc)",\r
1904                 "Thursday, April 5, 2001 5:43 PM",\r
1905             \r
1906                 cal.getDateTimeFormat(DateFormat.SHORT, DateFormat.FULL, loc),\r
1907                 "cal.getDateTimeFormat(DateFormat.SHORT, DateFormat.FULL, loc)",\r
1908                 "4/5/01 5:43:53 PM Pacific Daylight Time",\r
1909 \r
1910                 cal.getDateTimeFormat(DateFormat.FULL, DateFormat.SHORT, loc),\r
1911                 "cal.getDateTimeFormat(DateFormat.FULL, DateFormat.SHORT, loc)",\r
1912                 "Thursday, April 5, 2001 5:43 PM",\r
1913             };\r
1914             for (int i=0; i<DATA.length; i+=3) {\r
1915                 DateFormat df = (DateFormat) DATA[i];\r
1916                 String desc = (String) DATA[i+1];\r
1917                 String exp = (String) DATA[i+2];\r
1918                 String got = df.format(date);\r
1919                 if (got.equals(exp)) {\r
1920                     logln("Ok: " + desc + " => " + got);\r
1921                 } else {\r
1922                     errln("FAIL: " + desc + " => " + got + ", expected " + exp);\r
1923                 }\r
1924             }\r
1925         } finally {\r
1926             TimeZone.setDefault(zone);\r
1927         }\r
1928     }\r
1929 \r
1930     public void TestRegistration() {\r
1931         /*\r
1932          * Set names = Calendar.getCalendarFactoryNames();\r
1933          * \r
1934          * TimeZone tz = TimeZone.getDefault(); Locale loc =\r
1935          * Locale.getDefault(); Iterator iter = names.iterator(); while\r
1936          * (iter.hasNext()) { String name = (String)iter.next(); logln("Testing\r
1937          * factory: " + name);\r
1938          * \r
1939          * Calendar cal = Calendar.getInstance(tz, loc, name); logln("Calendar\r
1940          * class: " + cal.getClass());\r
1941          * \r
1942          * DateFormat fmt = cal.getDateTimeFormat(DateFormat.LONG,\r
1943          * DateFormat.LONG, loc);\r
1944          * \r
1945          * logln("Date: " + fmt.format(cal.getTime())); }\r
1946          *  // register new default for our locale logln("\nTesting\r
1947          * registration"); loc = new Locale("en", "US"); Object key =\r
1948          * Calendar.register(JapaneseCalendar.factory(), loc, true);\r
1949          * \r
1950          * loc = new Locale("en", "US", "TEST"); Calendar cal =\r
1951          * Calendar.getInstance(loc); logln("Calendar class: " +\r
1952          * cal.getClass()); DateFormat fmt =\r
1953          * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);\r
1954          * logln("Date: " + fmt.format(cal.getTime()));\r
1955          *  // force to use other default anyway logln("\nOverride\r
1956          * registration"); cal = Calendar.getInstance(tz, loc, "Gregorian"); fmt =\r
1957          * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);\r
1958          * logln("Date: " + fmt.format(cal.getTime()));\r
1959          *  // unregister default logln("\nUnregistration"); logln("Unregister\r
1960          * returned: " + Calendar.unregister(key)); cal =\r
1961          * Calendar.getInstance(tz, loc, "Gregorian"); fmt =\r
1962          * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);\r
1963          * logln("Date: " + fmt.format(cal.getTime()));\r
1964          */\r
1965     }\r
1966 \r
1967     /**\r
1968      * test serialize-and-modify.\r
1969      * @throws ClassNotFoundException \r
1970      */\r
1971     public void TestSerialization3474() {\r
1972         try {\r
1973             ByteArrayOutputStream icuStream = new ByteArrayOutputStream();\r
1974     \r
1975             logln("icu Calendar");\r
1976             \r
1977             com.ibm.icu.util.GregorianCalendar icuCalendar =\r
1978                 new com.ibm.icu.util.GregorianCalendar();\r
1979             \r
1980             icuCalendar.setTimeInMillis(1187912555931L);\r
1981             long expectMillis = 1187912520931L; // with seconds (not ms) cleared.\r
1982             \r
1983             logln("instantiated: "+icuCalendar);\r
1984             logln("getMillis: "+icuCalendar.getTimeInMillis());\r
1985             icuCalendar.set(com.ibm.icu.util.GregorianCalendar.SECOND, 0);\r
1986             logln("setSecond=0: "+icuCalendar);\r
1987             {\r
1988                 long gotMillis = icuCalendar.getTimeInMillis();\r
1989                 if(gotMillis != expectMillis) {\r
1990                     errln("expect millis "+expectMillis+" but got "+gotMillis);\r
1991                 } else {\r
1992                     logln("getMillis: "+gotMillis);\r
1993                 }\r
1994             }\r
1995             ObjectOutputStream icuOut =\r
1996                 new ObjectOutputStream(icuStream);\r
1997             icuOut.writeObject(icuCalendar);\r
1998             icuOut.flush();\r
1999             icuOut.close();\r
2000             \r
2001             ObjectInputStream icuIn =\r
2002                 new ObjectInputStream(new ByteArrayInputStream(icuStream.toByteArray()));\r
2003             icuCalendar = null;\r
2004             icuCalendar = (com.ibm.icu.util.GregorianCalendar)icuIn.readObject();\r
2005             \r
2006             logln("serialized back in: "+icuCalendar);\r
2007             {\r
2008                 long gotMillis = icuCalendar.getTimeInMillis();\r
2009                 if(gotMillis != expectMillis) {\r
2010                     errln("expect millis "+expectMillis+" but got "+gotMillis);\r
2011                 } else {\r
2012                     logln("getMillis: "+gotMillis);\r
2013                 }\r
2014             }\r
2015             \r
2016             icuCalendar.set(com.ibm.icu.util.GregorianCalendar.SECOND, 0);\r
2017                     \r
2018             logln("setSecond=0: "+icuCalendar);\r
2019             {\r
2020                 long gotMillis = icuCalendar.getTimeInMillis();\r
2021                 if(gotMillis != expectMillis) {\r
2022                     errln("expect millis "+expectMillis+" after stream and setSecond but got "+gotMillis);\r
2023                 } else {\r
2024                     logln("getMillis after stream and setSecond: "+gotMillis);\r
2025                 }\r
2026             }\r
2027         } catch(IOException e) {\r
2028             errln(e.toString());\r
2029             e.printStackTrace();\r
2030         } catch(ClassNotFoundException cnf) {\r
2031             errln(cnf.toString());\r
2032             cnf.printStackTrace();\r
2033         }\r
2034 \r
2035         // JDK works correctly, etc etc.  \r
2036 //        ByteArrayOutputStream jdkStream = new ByteArrayOutputStream();\r
2037 \r
2038 //        logln("\nSUN Calendar");\r
2039 //        \r
2040 //        java.util.GregorianCalendar sunCalendar =\r
2041 //            new java.util.GregorianCalendar();\r
2042 //        \r
2043 //        logln("instanzieren: "+sunCalendar);\r
2044 //        logln("getMillis: "+sunCalendar.getTimeInMillis());\r
2045 //        sunCalendar.set(java.util.GregorianCalendar.SECOND, 0);\r
2046 //        logln("setSecond=0: "+sunCalendar);\r
2047 //        logln("getMillis: "+sunCalendar.getTimeInMillis());\r
2048 //        \r
2049 //        ObjectOutputStream sunOut =\r
2050 //            new ObjectOutputStream(jdkStream);\r
2051 //        sunOut.writeObject(sunCalendar);\r
2052 //        sunOut.flush();\r
2053 //        sunOut.close();\r
2054 //        \r
2055 //        ObjectInputStream sunIn =\r
2056 //            new ObjectInputStream(new ByteArrayInputStream(jdkStream.toByteArray()));\r
2057 //        sunCalendar = null;\r
2058 //        sunCalendar = (java.util.GregorianCalendar)sunIn.readObject();\r
2059 //        \r
2060 //        logln("serialized: "+sunCalendar);\r
2061 //        logln("getMillis: "+sunCalendar.getTimeInMillis());\r
2062 //        \r
2063 //        sunCalendar.set(java.util.GregorianCalendar.SECOND, 0);\r
2064 //        logln("setSecond=0: "+sunCalendar);\r
2065 //        logln("getMillis: "+sunCalendar.getTimeInMillis());\r
2066         \r
2067     }\r
2068 \r
2069     public void TestYearJump3279() {\r
2070         final long time = 1041148800000L;\r
2071         Calendar c = new GregorianCalendar();\r
2072         DateFormat fmt = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, Locale.US);\r
2073 \r
2074         c.setTimeInMillis(time);\r
2075         int year1 = c.get(Calendar.YEAR);\r
2076         \r
2077         logln("time: " + fmt.format(new Date(c.getTimeInMillis())));\r
2078 \r
2079         logln("setting DOW to " + c.getFirstDayOfWeek());\r
2080         c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());\r
2081         logln("week: " + c.getTime());\r
2082         logln("week adjust: " + fmt.format(new Date(c.getTimeInMillis())));\r
2083         int year2 = c.get(Calendar.YEAR);\r
2084         \r
2085         if(year1 != year2) {\r
2086             errln("Error: adjusted day of week, and year jumped from " + year1 + " to " + year2);\r
2087         } else {\r
2088             logln("Year remained " + year2 + " - PASS.");\r
2089         }\r
2090     }\r
2091 \r
2092     public void TestGetKeywordValuesForLocale(){\r
2093 \r
2094         final String[][] PREFERRED = {\r
2095             {"root",        "gregorian"},\r
2096             {"und",         "gregorian"},\r
2097             {"en_US",       "gregorian"},\r
2098             {"en_029",      "gregorian"},\r
2099             {"th_TH",       "buddhist", "gregorian"},\r
2100             {"und_TH",      "buddhist", "gregorian"},\r
2101             {"en_TH",       "buddhist", "gregorian"},\r
2102             {"he_IL",       "gregorian", "hebrew", "islamic", "islamic-civil"},\r
2103             {"ar_EG",       "gregorian", "coptic", "islamic", "islamic-civil"},\r
2104             {"ja",          "gregorian", "japanese"},\r
2105             {"ps_Guru_IN",  "gregorian", "indian"},\r
2106             {"th@calendar=gregorian",   "buddhist", "gregorian"},\r
2107             {"en@calendar=islamic",     "gregorian"},\r
2108             {"zh_TW",       "gregorian", "roc", "chinese"},\r
2109             {"ar_IR",       "gregorian", "persian", "islamic", "islamic-civil"},\r
2110         };\r
2111 \r
2112         String[] ALL = Calendar.getKeywordValuesForLocale("calendar", ULocale.getDefault(), false);\r
2113         HashSet ALLSET = new HashSet();\r
2114         for (int i = 0; i < ALL.length; i++) {\r
2115             ALLSET.add(ALL[i]);\r
2116         }\r
2117 \r
2118         for (int i = 0; i < PREFERRED.length; i++) {\r
2119             ULocale loc = new ULocale(PREFERRED[i][0]);\r
2120             String[] expected = new String[PREFERRED[i].length - 1];\r
2121             System.arraycopy(PREFERRED[i], 1, expected, 0, expected.length);\r
2122 \r
2123             String[] pref = Calendar.getKeywordValuesForLocale("calendar", loc, true);\r
2124             boolean matchPref = false;\r
2125             if (pref.length == expected.length) {\r
2126                 matchPref = true;\r
2127                 for (int j = 0; j < pref.length; j++) {\r
2128                     if (!pref[j].equals(expected[j])) {\r
2129                         matchPref = false;\r
2130                     }\r
2131                 }\r
2132             }\r
2133             if (!matchPref) {\r
2134                 errln("FAIL: Preferred values for locale " + loc \r
2135                         + " got:" + Arrays.toString(pref) + " expected:" + Arrays.toString(expected));\r
2136             }\r
2137 \r
2138             String[] all = Calendar.getKeywordValuesForLocale("calendar", loc, false);\r
2139             boolean matchAll = false;\r
2140             if (all.length == ALLSET.size()) {\r
2141                 matchAll = true;\r
2142                 for (int j = 0; j < all.length; j++) {\r
2143                     if (!ALLSET.contains(all[j])) {\r
2144                         matchAll = false;\r
2145                         break;\r
2146                     }\r
2147                 }\r
2148             }\r
2149             if (!matchAll) {\r
2150                 errln("FAIL: All values for locale " + loc\r
2151                         + " got:" + Arrays.toString(all)); \r
2152             }\r
2153         }\r
2154     }\r
2155 \r
2156 }\r
2157 \r
2158 //eof\r