jars/icu4j-4_2_1-src/src/com/ibm/icu/dev/test/calendar/CalendarRegression.java

   1 //##header\r
   2 /**\r
   3  *******************************************************************************\r
   4  * Copyright (C) 2000-2009, International Business Machines Corporation and    *\r
   5  * others. All Rights Reserved.                                                *\r
   6  *******************************************************************************\r
   7  */\r
   8 package com.ibm.icu.dev.test.calendar;\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.Date;\r
  15 import java.util.HashSet;\r
  16 import java.util.Locale;\r
  17 import java.util.MissingResourceException;\r
  18 \r
  19 import com.ibm.icu.impl.Utility;\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 //#if defined(FOUNDATION10) || defined(J2SE13)\r
 827 //##        // This test case does not work well with JRE1.3 with\r
 828 //##        // the timezone update for US 2007 rule.  Java 1.3 only\r
 829 //##        // supports single DST rule for all years.  March 15\r
 830 //##        // was not in DST before, but with the new rule, it is\r
 831 //##        // in DST.\r
 832 //#else\r
 833         cal.setTime(d11);\r
 834         cal.clear( Calendar.MONTH ); \r
 835         logln(cal.getTime().toString()); \r
 836         if (!cal.getTime().equals(dM)) {\r
 837             errln("Fail: " + d11 + " clear(MONTH) => expect " +\r
 838                   dM + ", got " + cal.getTime());\r
 839         }\r
 840 //#endif\r
 841     }\r
 842 \r
 843     public void Test4114578() {\r
 844         int ONE_HOUR = 60*60*1000;\r
 845         Calendar cal = Calendar.getInstance();\r
 846         cal.setTimeZone(TimeZone.getTimeZone("PST"));\r
 847         \r
 848         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 849         tempcal.clear();\r
 850         tempcal.set(1998, Calendar.APRIL, 5, 1, 0);\r
 851         long onset = tempcal.getTime().getTime() + ONE_HOUR;\r
 852         tempcal.set(1998, Calendar.OCTOBER, 25, 0, 0);\r
 853         long cease = tempcal.getTime().getTime() + 2*ONE_HOUR;\r
 854 \r
 855         boolean fail = false;\r
 856         \r
 857         final int ADD = 1;\r
 858         final int ROLL = 2;\r
 859 \r
 860         long[] DATA = {\r
 861             // Start Action Amt Expected_change\r
 862             onset - ONE_HOUR,   ADD,      1,     ONE_HOUR,\r
 863             onset,              ADD,     -1,    -ONE_HOUR,\r
 864             onset - ONE_HOUR,   ROLL,     1,     ONE_HOUR,\r
 865             onset,              ROLL,    -1,    -ONE_HOUR,\r
 866             cease - ONE_HOUR,   ADD,      1,     ONE_HOUR,\r
 867             cease,              ADD,     -1,    -ONE_HOUR,\r
 868             cease - ONE_HOUR,   ROLL,     1,     ONE_HOUR,\r
 869             cease,              ROLL,    -1,    -ONE_HOUR,\r
 870         };\r
 871 \r
 872         for (int i=0; i<DATA.length; i+=4) {\r
 873             Date date = new Date(DATA[i]);\r
 874             int amt = (int) DATA[i+2];\r
 875             long expectedChange = DATA[i+3];\r
 876             \r
 877             log(date.toString());\r
 878             cal.setTime(date);\r
 879 \r
 880             switch ((int) DATA[i+1]) {\r
 881             case ADD:\r
 882                 log(" add (HOUR," + (amt<0?"":"+")+amt + ")= ");\r
 883                 cal.add(Calendar.HOUR, amt);\r
 884                 break;\r
 885             case ROLL:\r
 886                 log(" roll(HOUR," + (amt<0?"":"+")+amt + ")= ");\r
 887                 cal.roll(Calendar.HOUR, amt);\r
 888                 break;\r
 889             }\r
 890 \r
 891             log(cal.getTime().toString());\r
 892 \r
 893             long change = cal.getTime().getTime() - date.getTime();\r
 894             if (change != expectedChange) {\r
 895                 fail = true;\r
 896                 logln(" FAIL");\r
 897             }\r
 898             else logln(" OK");\r
 899         }\r
 900 \r
 901         if (fail) errln("Fail: roll/add misbehaves around DST onset/cease");\r
 902     }\r
 903 \r
 904     /**\r
 905      * Make sure maximum for HOUR field is 11, not 12.\r
 906      */\r
 907     public void Test4118384() {\r
 908         Calendar cal = Calendar.getInstance();\r
 909         if (cal.getMaximum(Calendar.HOUR) != 11 ||\r
 910             cal.getLeastMaximum(Calendar.HOUR) != 11 ||\r
 911             cal.getActualMaximum(Calendar.HOUR) != 11)\r
 912             errln("Fail: maximum of HOUR field should be 11");\r
 913     }\r
 914 \r
 915     /**\r
 916      * Check isLeapYear for BC years.\r
 917      */\r
 918     public void Test4125881() {\r
 919         GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();\r
 920         DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");\r
 921         cal.clear();\r
 922         for (int y=-20; y<=10; ++y) {\r
 923             cal.set(Calendar.ERA, y < 1 ? GregorianCalendar.BC : GregorianCalendar.AD);\r
 924             cal.set(Calendar.YEAR, y < 1 ? 1 - y : y);\r
 925             logln(y + " = " + fmt.format(cal.getTime()) + " " +\r
 926                                cal.isLeapYear(y));\r
 927             if (cal.isLeapYear(y) != ((y+40)%4 == 0))\r
 928                 errln("Leap years broken");\r
 929         }\r
 930     }\r
 931 \r
 932     // I am disabling this test -- it is currently failing because of a bug\r
 933     // in Sun's latest change to STZ.getOffset(). I have filed a Sun bug\r
 934     // against this problem.\r
 935 \r
 936     // Re-enabled after 'porting' TZ and STZ from java.util to com.ibm.icu.util.\r
 937     /**\r
 938      * Prove that GregorianCalendar is proleptic (it used to cut off at 45 BC,\r
 939      * and not have leap years before then).\r
 940      */\r
 941     public void Test4125892() {\r
 942         GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();\r
 943         //DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");\r
 944         //fmt = null;\r
 945         cal.clear();\r
 946         cal.set(Calendar.ERA, GregorianCalendar.BC);\r
 947         cal.set(Calendar.YEAR, 81); // 81 BC is a leap year (proleptically)\r
 948         cal.set(Calendar.MONTH, Calendar.FEBRUARY);\r
 949         cal.set(Calendar.DATE, 28);\r
 950         cal.add(Calendar.DATE, 1);\r
 951         if (cal.get(Calendar.DATE) != 29 ||\r
 952             !cal.isLeapYear(-80)) // -80 == 81 BC\r
 953             errln("Calendar not proleptic");\r
 954     }\r
 955 \r
 956     /**\r
 957      * Calendar and GregorianCalendar hashCode() methods need improvement.\r
 958      * Calendar needs a good implementation that subclasses can override, and\r
 959      * GregorianCalendar should use that implementation.\r
 960      */\r
 961     public void Test4136399() {\r
 962         /*\r
 963          * Note: This test is actually more strict than it has to be.\r
 964          * Technically, there is no requirement that unequal objects have\r
 965          * unequal hashes. We only require equal objects to have equal hashes.\r
 966          * It is desirable for unequal objects to have distributed hashes, but\r
 967          * there is no hard requirement here.\r
 968          * \r
 969          * In this test we make assumptions about certain attributes of calendar\r
 970          * objects getting represented in the hash, which need not always be the\r
 971          * case (although it does work currently with the given test).\r
 972          */\r
 973         Calendar a = Calendar.getInstance();\r
 974         Calendar b = (Calendar)a.clone();\r
 975         if (a.hashCode() != b.hashCode()) {\r
 976             errln("Calendar hash code unequal for cloned objects");\r
 977         }\r
 978         TimeZone atz1 = a.getTimeZone();\r
 979         TimeZone atz2 = (TimeZone)atz1.clone();\r
 980         if(!atz1.equals(atz2)){\r
 981             errln("The clone timezones are not equal");\r
 982         }\r
 983         if(atz1.hashCode()!=atz2.hashCode()){\r
 984             errln("TimeZone hash code unequal for cloned objects");\r
 985         }\r
 986         b.setMinimalDaysInFirstWeek(7 - a.getMinimalDaysInFirstWeek());\r
 987         if (a.hashCode() == b.hashCode()) {\r
 988             errln("Calendar hash code ignores minimal days in first week");\r
 989         }\r
 990         b.setMinimalDaysInFirstWeek(a.getMinimalDaysInFirstWeek());\r
 991 \r
 992         b.setFirstDayOfWeek((a.getFirstDayOfWeek() % 7) + 1); // Next day\r
 993         if (a.hashCode() == b.hashCode()) {\r
 994             errln("Calendar hash code ignores first day of week");\r
 995         }\r
 996         b.setFirstDayOfWeek(a.getFirstDayOfWeek());\r
 997 \r
 998         b.setLenient(!a.isLenient());\r
 999         if (a.hashCode() == b.hashCode()) {\r
1000             errln("Calendar hash code ignores lenient setting");\r
1001         }\r
1002         b.setLenient(a.isLenient());\r
1003         \r
1004         // Assume getTimeZone() returns a reference, not a clone\r
1005         // of a reference -- this is true as of this writing\r
1006         TimeZone atz = a.getTimeZone();\r
1007         TimeZone btz = b.getTimeZone();\r
1008 \r
1009         btz.setRawOffset(atz.getRawOffset() + 60*60*1000);\r
1010         if(atz.hashCode()== btz.hashCode()){\r
1011             errln(atz.hashCode()+"=="+btz.hashCode());\r
1012         }\r
1013         if (a.getTimeZone()!= b.getTimeZone() && a.hashCode() == b.hashCode()) {\r
1014             errln("Calendar hash code ignores zone");\r
1015         }\r
1016         b.getTimeZone().setRawOffset(a.getTimeZone().getRawOffset());\r
1017 \r
1018         GregorianCalendar c = new GregorianCalendar();\r
1019         GregorianCalendar d = (GregorianCalendar)c.clone();\r
1020         if (c.hashCode() != d.hashCode()) {\r
1021             errln("GregorianCalendar hash code unequal for clones objects");\r
1022         }\r
1023         Date cutover = c.getGregorianChange();\r
1024         d.setGregorianChange(new Date(cutover.getTime() + 24*60*60*1000));\r
1025         if (c.hashCode() == d.hashCode()) {\r
1026             errln("GregorianCalendar hash code ignores cutover");\r
1027         }        \r
1028     }\r
1029 \r
1030     /**\r
1031      * GregorianCalendar.equals() ignores cutover date\r
1032      */\r
1033     public void Test4141665() {\r
1034         GregorianCalendar cal = new GregorianCalendar();\r
1035         GregorianCalendar cal2 = (GregorianCalendar)cal.clone();\r
1036         Date cut = cal.getGregorianChange();\r
1037         Date cut2 = new Date(cut.getTime() + 100*24*60*60*1000L); // 100 days\r
1038                                                                   // later\r
1039         if (!cal.equals(cal2)) {\r
1040             errln("Cloned GregorianCalendars not equal");\r
1041         }\r
1042         cal2.setGregorianChange(cut2);\r
1043         if (cal.equals(cal2)) {\r
1044             errln("GregorianCalendar.equals() ignores cutover");\r
1045         }\r
1046     }\r
1047     \r
1048     /**\r
1049      * Bug states that ArrayIndexOutOfBoundsException is thrown by\r
1050      * GregorianCalendar.roll() when IllegalArgumentException should be.\r
1051      */\r
1052     public void Test4142933() {\r
1053         GregorianCalendar calendar = new GregorianCalendar();\r
1054         try {\r
1055             calendar.roll(-1, true);\r
1056             errln("Test failed, no exception trown");\r
1057         }\r
1058         catch (IllegalArgumentException e) {\r
1059             // OK: Do nothing\r
1060             // logln("Test passed");\r
1061             System.out.print("");\r
1062         }\r
1063         catch (Exception e) {\r
1064             errln("Test failed. Unexpected exception is thrown: " + e);\r
1065             e.printStackTrace();\r
1066         } \r
1067     }\r
1068 \r
1069     /**\r
1070      * GregorianCalendar handling of Dates Long.MIN_VALUE and Long.MAX_VALUE is\r
1071      * confusing; unless the time zone has a raw offset of zero, one or the\r
1072      * other of these will wrap. We've modified the test given in the bug report\r
1073      * to therefore only check the behavior of a calendar with a zero raw offset\r
1074      * zone.\r
1075      */\r
1076     public void Test4145158() {\r
1077         GregorianCalendar calendar = new GregorianCalendar();\r
1078 \r
1079         calendar.setTimeZone(TimeZone.getTimeZone("GMT"));\r
1080 \r
1081         calendar.setTime(new Date(Long.MIN_VALUE));\r
1082         int year1 = calendar.get(Calendar.YEAR);\r
1083         int era1 = calendar.get(Calendar.ERA);\r
1084         \r
1085         calendar.setTime(new Date(Long.MAX_VALUE));\r
1086         int year2 = calendar.get(Calendar.YEAR);\r
1087         int era2 = calendar.get(Calendar.ERA);\r
1088         \r
1089         if (year1 == year2 && era1 == era2) {\r
1090             errln("Fail: Long.MIN_VALUE or Long.MAX_VALUE wrapping around");\r
1091         }\r
1092     }\r
1093 \r
1094     /**\r
1095      * Maximum value for YEAR field wrong.\r
1096      */\r
1097     public void Test4145983() {\r
1098         GregorianCalendar calendar = new GregorianCalendar();\r
1099         calendar.setTimeZone(TimeZone.getTimeZone("GMT"));\r
1100         Date[] DATES = { new Date(Long.MAX_VALUE), new Date(Long.MIN_VALUE) };\r
1101         for (int i=0; i<DATES.length; ++i) {\r
1102             calendar.setTime(DATES[i]);\r
1103             int year = calendar.get(Calendar.YEAR);\r
1104             int maxYear = calendar.getMaximum(Calendar.YEAR);\r
1105             if (year > maxYear) {\r
1106                 errln("Failed for "+DATES[i].getTime()+" ms: year=" +\r
1107                       year + ", maxYear=" + maxYear);\r
1108             }\r
1109         }\r
1110     }\r
1111 \r
1112     /**\r
1113      * This is a bug in the validation code of GregorianCalendar. As reported,\r
1114      * the bug seems worse than it really is, due to a bug in the way the bug\r
1115      * report test was written. In reality the bug is restricted to the\r
1116      * DAY_OF_YEAR field. - liu 6/29/98\r
1117      */\r
1118     public void Test4147269() {\r
1119         GregorianCalendar calendar = new GregorianCalendar();\r
1120         calendar.setLenient(false);\r
1121         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
1122         tempcal.clear();\r
1123         tempcal.set(1996, Calendar.JANUARY, 3); // Arbitrary date\r
1124         Date date = tempcal.getTime(); \r
1125         for (int field = 0; field < calendar.getFieldCount(); field++) {\r
1126             calendar.setTime(date);\r
1127             // Note: In the bug report, getActualMaximum() was called instead\r
1128             // of getMaximum() -- this was an error. The validation code doesn't\r
1129             // use getActualMaximum(), since that's too costly.\r
1130             int max = calendar.getMaximum(field);\r
1131             int value = max+1;\r
1132             calendar.set(field, value); \r
1133             try {\r
1134                 calendar.getTime(); // Force time computation\r
1135                 // We expect an exception to be thrown. If we fall through\r
1136                 // to the next line, then we have a bug.\r
1137                 errln("Test failed with field " + FIELD_NAME[field] +\r
1138                       ", date before: " + date +\r
1139                       ", date after: " + calendar.getTime() +\r
1140                       ", value: " + value + " (max = " + max +")");\r
1141             } catch (IllegalArgumentException e) {\r
1142                 System.out.print("");\r
1143             } \r
1144         }\r
1145     }\r
1146 \r
1147     /**\r
1148      * Reported bug is that a GregorianCalendar with a cutover of\r
1149      * Date(Long.MAX_VALUE) doesn't behave as a pure Julian calendar. CANNOT\r
1150      * REPRODUCE THIS BUG\r
1151      */\r
1152     public void Test4149677() {\r
1153         TimeZone[] zones = { TimeZone.getTimeZone("GMT"),\r
1154                              TimeZone.getTimeZone("PST"),\r
1155                              TimeZone.getTimeZone("EAT") };\r
1156         for (int i=0; i<zones.length; ++i) {\r
1157             GregorianCalendar calendar = new GregorianCalendar(zones[i]);\r
1158 \r
1159             // Make sure extreme values don't wrap around\r
1160             calendar.setTime(new Date(Long.MIN_VALUE));\r
1161             if (calendar.get(Calendar.ERA) != GregorianCalendar.BC) {\r
1162                 errln("Fail: Long.MIN_VALUE ms has an AD year");\r
1163             }\r
1164             calendar.setTime(new Date(Long.MAX_VALUE));\r
1165             if (calendar.get(Calendar.ERA) != GregorianCalendar.AD) {\r
1166                 errln("Fail: Long.MAX_VALUE ms has a BC year");\r
1167             }\r
1168 \r
1169             calendar.setGregorianChange(new Date(Long.MAX_VALUE));\r
1170             // to obtain a pure Julian calendar\r
1171             \r
1172             boolean is100Leap = calendar.isLeapYear(100);\r
1173             if (!is100Leap) {\r
1174                 errln("test failed with zone " + zones[i].getID());\r
1175                 errln(" cutover date is Calendar.MAX_DATE");\r
1176                 errln(" isLeapYear(100) returns: " + is100Leap);\r
1177             }\r
1178         }\r
1179     }\r
1180 \r
1181     /**\r
1182      * Calendar and Date HOUR broken. If HOUR is out-of-range, Calendar and Date\r
1183      * classes will misbehave.\r
1184      */\r
1185     public void Test4162587() {\r
1186         TimeZone tz = TimeZone.getTimeZone("PST");\r
1187         TimeZone.setDefault(tz);\r
1188         GregorianCalendar cal = new GregorianCalendar(tz);\r
1189         Date d;\r
1190         \r
1191         for (int i=0; i<5; ++i) {\r
1192             if (i>0) logln("---");\r
1193 \r
1194             cal.clear();\r
1195             cal.set(1998, Calendar.APRIL, 5, i, 0);\r
1196             d = cal.getTime();\r
1197             String s0 = d.toString();\r
1198             logln("0 " + i + ": " + s0);\r
1199 \r
1200             cal.clear();\r
1201             cal.set(1998, Calendar.APRIL, 4, i+24, 0);\r
1202             d = cal.getTime();\r
1203             String sPlus = d.toString();\r
1204             logln("+ " + i + ": " + sPlus);\r
1205 \r
1206             cal.clear();\r
1207             cal.set(1998, Calendar.APRIL, 6, i-24, 0);\r
1208             d = cal.getTime();\r
1209             String sMinus = d.toString();\r
1210             logln("- " + i + ": " + sMinus);\r
1211 \r
1212             if (!s0.equals(sPlus) || !s0.equals(sMinus)) {\r
1213                 errln("Fail: All three lines must match");\r
1214             }\r
1215         }\r
1216     }\r
1217 \r
1218     /**\r
1219      * Adding 12 months behaves differently from adding 1 year\r
1220      */\r
1221     public void Test4165343() {\r
1222         GregorianCalendar calendar = new GregorianCalendar(1996, Calendar.FEBRUARY, 29);\r
1223         Date start = calendar.getTime();\r
1224         logln("init date: " + start);\r
1225         calendar.add(Calendar.MONTH, 12); \r
1226         Date date1 = calendar.getTime();\r
1227         logln("after adding 12 months: " + date1);\r
1228         calendar.setTime(start);\r
1229         calendar.add(Calendar.YEAR, 1);\r
1230         Date date2 = calendar.getTime();\r
1231         logln("after adding one year : " + date2);\r
1232         if (date1.equals(date2)) {\r
1233             logln("Test passed");\r
1234         } else {\r
1235             errln("Test failed");\r
1236         }\r
1237     }\r
1238 \r
1239     /**\r
1240      * GregorianCalendar.getActualMaximum() does not account for first day of\r
1241      * week.\r
1242      */\r
1243     public void Test4166109() {\r
1244         /*\r
1245          * Test month:\r
1246          * \r
1247          * 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
1248          * 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31\r
1249          */\r
1250         boolean passed = true;\r
1251         int field = Calendar.WEEK_OF_MONTH;\r
1252 \r
1253         GregorianCalendar calendar = new GregorianCalendar(Locale.US);\r
1254         calendar.set(1998, Calendar.MARCH, 1);\r
1255         calendar.setMinimalDaysInFirstWeek(1);\r
1256         logln("Date:  " + calendar.getTime());\r
1257 \r
1258         int firstInMonth = calendar.get(Calendar.DAY_OF_MONTH);\r
1259 \r
1260         for (int firstInWeek = Calendar.SUNDAY; firstInWeek <= Calendar.SATURDAY; firstInWeek++) {\r
1261             calendar.setFirstDayOfWeek(firstInWeek);\r
1262             int returned = calendar.getActualMaximum(field);\r
1263             int expected = (31 + ((firstInMonth - firstInWeek + 7)% 7) + 6) / 7;\r
1264 \r
1265             logln("First day of week = " + firstInWeek +\r
1266                   "  getActualMaximum(WEEK_OF_MONTH) = " + returned +\r
1267                   "  expected = " + expected +\r
1268                   ((returned == expected) ? "  ok" : "  FAIL"));\r
1269 \r
1270             if (returned != expected) {\r
1271                 passed = false;\r
1272             }\r
1273         }\r
1274         if (!passed) {\r
1275             errln("Test failed");\r
1276         }\r
1277     }\r
1278 \r
1279     /**\r
1280      * Calendar.getActualMaximum(YEAR) works wrong.\r
1281      */\r
1282     public void Test4167060() {\r
1283         int field = Calendar.YEAR;\r
1284         DateFormat format = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy G",\r
1285                                                  Locale.US);\r
1286 \r
1287         GregorianCalendar calendars[] = {\r
1288             new GregorianCalendar(100, Calendar.NOVEMBER, 1),\r
1289             new GregorianCalendar(-99 /* 100BC */, Calendar.JANUARY, 1),\r
1290             new GregorianCalendar(1996, Calendar.FEBRUARY, 29),\r
1291         };\r
1292 \r
1293         String[] id = { "Hybrid", "Gregorian", "Julian" };\r
1294 \r
1295         for (int k=0; k<3; ++k) {\r
1296             logln("--- " + id[k] + " ---");\r
1297 \r
1298             for (int j=0; j<calendars.length; ++j) {\r
1299                 GregorianCalendar calendar = calendars[j];\r
1300                 if (k == 1) {\r
1301                     calendar.setGregorianChange(new Date(Long.MIN_VALUE));\r
1302                 } else if (k == 2) {\r
1303                     calendar.setGregorianChange(new Date(Long.MAX_VALUE));\r
1304                 }\r
1305 \r
1306                 format.setCalendar((Calendar)calendar.clone());\r
1307 \r
1308                 Date dateBefore = calendar.getTime();\r
1309 \r
1310                 int maxYear = calendar.getActualMaximum(field);\r
1311                 logln("maxYear: " + maxYear + " for " + format.format(calendar.getTime()));\r
1312                 logln("date before: " + format.format(dateBefore));\r
1313 \r
1314                 int years[] = {2000, maxYear-1, maxYear, maxYear+1};\r
1315 \r
1316                 for (int i = 0; i < years.length; i++) {\r
1317                     boolean valid = years[i] <= maxYear;\r
1318                     calendar.set(field, years[i]);\r
1319                     Date dateAfter = calendar.getTime();\r
1320                     int newYear = calendar.get(field);\r
1321                     calendar.setTime(dateBefore); // restore calendar for next\r
1322                                                   // use\r
1323 \r
1324                     logln(" Year " + years[i] + (valid? " ok " : " bad") +\r
1325                           " => " + format.format(dateAfter));\r
1326                     if (valid && newYear != years[i]) {\r
1327                         errln("  FAIL: " + newYear + " should be valid; date, month and time shouldn't change");\r
1328                     } else if (!valid && newYear == years[i]) {\r
1329                         // We no longer require strict year maxima. That is, the\r
1330                         // calendar\r
1331                         // algorithm may work for values > the stated maximum.\r
1332                         //errln(" FAIL: " + newYear + " should be invalid");\r
1333                         logln("  Note: " + newYear + " > maximum, but still valid");\r
1334                     }\r
1335                 }\r
1336             }\r
1337         }\r
1338     }\r
1339 \r
1340     /**\r
1341      * Calendar.roll broken This bug relies on the TimeZone bug 4173604 to also\r
1342      * be fixed.\r
1343      */\r
1344     public void Test4173516() {\r
1345         int fieldsList[][] = {\r
1346             { 1997, Calendar.FEBRUARY,  1, 10, 45, 15, 900 },\r
1347             { 1999, Calendar.DECEMBER, 22, 23, 59, 59, 999 }\r
1348         };\r
1349         int limit = 40;\r
1350         GregorianCalendar cal = new GregorianCalendar();\r
1351 \r
1352         cal.setTime(new Date(0));\r
1353         cal.roll(Calendar.HOUR,  0x7F000000);\r
1354         cal.roll(Calendar.HOUR, -0x7F000000);\r
1355         if (cal.getTime().getTime() != 0) {\r
1356             errln("Hour rolling broken");\r
1357         }\r
1358 \r
1359         for (int op=0; op<2; ++op) {\r
1360             logln("Testing GregorianCalendar " +\r
1361                   (op==0 ? "add" : "roll"));\r
1362             for (int field=0; field < cal.getFieldCount(); ++field) {\r
1363                 if (field != Calendar.ZONE_OFFSET &&\r
1364                     field != Calendar.DST_OFFSET) {\r
1365                     for (int j=0; j<fieldsList.length; ++j) {\r
1366                         int fields[] = fieldsList[j];\r
1367                         cal.clear();\r
1368                         cal.set(fields[0], fields[1], fields[2],\r
1369                                 fields[3], fields[4], fields[5]);\r
1370                         cal.set(Calendar.MILLISECOND, fields[6]);\r
1371                         cal.setMinimalDaysInFirstWeek(1);\r
1372                         for (int i = 0; i < 2*limit; i++) {\r
1373                             if (op == 0) {\r
1374                                 cal.add(field, i < limit ? 1 : -1);\r
1375                             } else {\r
1376                                 cal.roll(field, i < limit ? 1 : -1);\r
1377                             }\r
1378                         }\r
1379                         if (cal.get(Calendar.YEAR) != fields[0] ||\r
1380                             cal.get(Calendar.MONTH) != fields[1] ||\r
1381                             cal.get(Calendar.DATE) != fields[2] ||\r
1382                             cal.get(Calendar.HOUR_OF_DAY) != fields[3] ||\r
1383                             cal.get(Calendar.MINUTE) != fields[4] ||\r
1384                             cal.get(Calendar.SECOND) != fields[5] ||\r
1385                             cal.get(Calendar.MILLISECOND) != fields[6]) {\r
1386                             errln("Field " + field +\r
1387                                   " (" + FIELD_NAME[field] +\r
1388                                   ") FAIL, expected " +\r
1389                                   fields[0] +\r
1390                                   "/" + (fields[1] + 1) +\r
1391                                   "/" + fields[2] +\r
1392                                   " " + fields[3] +\r
1393                                   ":" + fields[4] +\r
1394                                   ":" + fields[5] +\r
1395                                   "." + fields[6] +\r
1396                                   ", got " + cal.get(Calendar.YEAR) +\r
1397                                   "/" + (cal.get(Calendar.MONTH) + 1) +\r
1398                                   "/" + cal.get(Calendar.DATE) +\r
1399                                   " " + cal.get(Calendar.HOUR_OF_DAY) +\r
1400                                   ":" + cal.get(Calendar.MINUTE) +\r
1401                                   ":" + cal.get(Calendar.SECOND) +\r
1402                                   "." + cal.get(Calendar.MILLISECOND));\r
1403                             cal.clear();\r
1404                             cal.set(fields[0], fields[1], fields[2],\r
1405                                     fields[3], fields[4], fields[5]);\r
1406                             cal.set(Calendar.MILLISECOND, fields[6]);\r
1407                             logln("Start date: " + cal.get(Calendar.YEAR) +\r
1408                                   "/" + (cal.get(Calendar.MONTH) + 1) +\r
1409                                   "/" + cal.get(Calendar.DATE) +\r
1410                                   " " + cal.get(Calendar.HOUR_OF_DAY) +\r
1411                                   ":" + cal.get(Calendar.MINUTE) +\r
1412                                   ":" + cal.get(Calendar.SECOND) +\r
1413                                   "." + cal.get(Calendar.MILLISECOND));\r
1414                             long prev = cal.getTime().getTime();\r
1415                             for (int i = 0; i < 2*limit; i++) {\r
1416                                 if (op == 0) {\r
1417                                     cal.add(field, i < limit ? 1 : -1);\r
1418                                 } else {\r
1419                                     cal.roll(field, i < limit ? 1 : -1);\r
1420                                 }\r
1421                                 long t = cal.getTime().getTime();\r
1422                                 long delta = t - prev;\r
1423                                 prev = t;\r
1424                                 logln((op == 0 ? "add(" : "roll(") + FIELD_NAME[field] +\r
1425                                       (i < limit ? ", +1) => " : ", -1) => ") +\r
1426                                       cal.get(Calendar.YEAR) +\r
1427                                       "/" + (cal.get(Calendar.MONTH) + 1) +\r
1428                                       "/" + cal.get(Calendar.DATE) +\r
1429                                       " " + cal.get(Calendar.HOUR_OF_DAY) +\r
1430                                       ":" + cal.get(Calendar.MINUTE) +\r
1431                                       ":" + cal.get(Calendar.SECOND) +\r
1432                                       "." + cal.get(Calendar.MILLISECOND) +\r
1433                                       " delta=" + delta + " ms");\r
1434                             }\r
1435                         }\r
1436                     }\r
1437                 }\r
1438             }\r
1439         }\r
1440     }\r
1441 \r
1442     public void Test4174361() {\r
1443         GregorianCalendar calendar = new GregorianCalendar(1996, 1, 29);\r
1444 \r
1445         calendar.add(Calendar.MONTH, 10); \r
1446         //Date date1 = calendar.getTime();\r
1447         //date1 = null;\r
1448         int d1 = calendar.get(Calendar.DAY_OF_MONTH);\r
1449 \r
1450         calendar = new GregorianCalendar(1996, 1, 29);\r
1451         calendar.add(Calendar.MONTH, 11); \r
1452         //Date date2 = calendar.getTime();\r
1453         //date2 = null;\r
1454         int d2 = calendar.get(Calendar.DAY_OF_MONTH);\r
1455 \r
1456         if (d1 != d2) {\r
1457             errln("adding months to Feb 29 broken");\r
1458         }\r
1459     }\r
1460 \r
1461     /**\r
1462      * Calendar does not update field values when setTimeZone is called.\r
1463      */\r
1464     public void Test4177484() {\r
1465         TimeZone PST = TimeZone.getTimeZone("PST");\r
1466         TimeZone EST = TimeZone.getTimeZone("EST");\r
1467 \r
1468         Calendar cal = Calendar.getInstance(PST, Locale.US);\r
1469         cal.clear();\r
1470         cal.set(1999, 3, 21, 15, 5, 0); // Arbitrary\r
1471         int h1 = cal.get(Calendar.HOUR_OF_DAY);\r
1472         cal.setTimeZone(EST);\r
1473         int h2 = cal.get(Calendar.HOUR_OF_DAY);\r
1474         if (h1 == h2) {\r
1475             errln("FAIL: Fields not updated after setTimeZone");\r
1476         }\r
1477 \r
1478         // getTime() must NOT change when time zone is changed.\r
1479         // getTime() returns zone-independent time in ms.\r
1480         cal.clear();\r
1481         cal.setTimeZone(PST);\r
1482         cal.set(Calendar.HOUR_OF_DAY, 10);\r
1483         Date pst10 = cal.getTime();\r
1484         cal.setTimeZone(EST);\r
1485         Date est10 = cal.getTime();\r
1486         if (!pst10.equals(est10)) {\r
1487             errln("FAIL: setTimeZone changed time");\r
1488         }\r
1489     }\r
1490 \r
1491     /**\r
1492      * Week of year is wrong at the start and end of the year.\r
1493      */\r
1494     public void Test4197699() {\r
1495         GregorianCalendar cal = new GregorianCalendar();\r
1496         cal.setFirstDayOfWeek(Calendar.MONDAY);\r
1497         cal.setMinimalDaysInFirstWeek(4);\r
1498         DateFormat fmt = new SimpleDateFormat("E dd MMM yyyy  'DOY='D 'WOY='w");\r
1499         fmt.setCalendar(cal);\r
1500 \r
1501         int[] DATA = {\r
1502             2000,  Calendar.JANUARY,   1,   52,\r
1503             2001,  Calendar.DECEMBER,  31,  1,\r
1504         };\r
1505 \r
1506         for (int i=0; i<DATA.length; ) {\r
1507             cal.set(DATA[i++], DATA[i++], DATA[i++]);\r
1508             int expWOY = DATA[i++];\r
1509             int actWOY = cal.get(Calendar.WEEK_OF_YEAR);\r
1510             if (expWOY == actWOY) {\r
1511                 logln("Ok: " + fmt.format(cal.getTime()));\r
1512             } else {\r
1513                 errln("FAIL: " + fmt.format(cal.getTime())\r
1514                       + ", expected WOY=" + expWOY);\r
1515                 cal.add(Calendar.DATE, -8);\r
1516                 for (int j=0; j<14; ++j) {\r
1517                     cal.add(Calendar.DATE, 1);\r
1518                     logln(fmt.format(cal.getTime()));\r
1519                 }\r
1520             }\r
1521         }\r
1522     }\r
1523 \r
1524     /**\r
1525      * Calendar DAY_OF_WEEK_IN_MONTH fields->time broken. The problem is in the\r
1526      * field disambiguation code in GregorianCalendar. This code is supposed to\r
1527      * choose the most recent set of fields among the following:\r
1528      * \r
1529      * MONTH + DAY_OF_MONTH MONTH + WEEK_OF_MONTH + DAY_OF_WEEK MONTH +\r
1530      * DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK DAY_OF_YEAR WEEK_OF_YEAR + DAY_OF_WEEK\r
1531      */\r
1532     public void Test4209071() {\r
1533         Calendar cal = Calendar.getInstance(Locale.US);\r
1534 \r
1535         // General field setting test\r
1536         int Y = 1995;\r
1537         \r
1538         Date d[] = new Date[13];\r
1539         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
1540         tempcal.clear();\r
1541         tempcal.set(Y, Calendar.JANUARY, 1);\r
1542         d[0] = tempcal.getTime();\r
1543         tempcal.set(Y, Calendar.MARCH, 1);\r
1544         d[1] = tempcal.getTime();\r
1545         tempcal.set(Y, Calendar.JANUARY, 4);\r
1546         d[2] = tempcal.getTime();\r
1547         tempcal.set(Y, Calendar.JANUARY, 18);\r
1548         d[3] = tempcal.getTime();\r
1549         tempcal.set(Y, Calendar.JANUARY, 18);\r
1550         d[4] = tempcal.getTime();\r
1551         tempcal.set(Y-1, Calendar.DECEMBER, 22);\r
1552         d[5] = tempcal.getTime();\r
1553         tempcal.set(Y, Calendar.JANUARY, 26);\r
1554         d[6] = tempcal.getTime();\r
1555         tempcal.set(Y, Calendar.JANUARY, 26);\r
1556         d[7] = tempcal.getTime();\r
1557         tempcal.set(Y, Calendar.MARCH, 1);\r
1558         d[8] = tempcal.getTime();\r
1559         tempcal.set(Y, Calendar.OCTOBER, 6);\r
1560         d[9] = tempcal.getTime();\r
1561         tempcal.set(Y, Calendar.OCTOBER, 13);\r
1562         d[10] = tempcal.getTime();\r
1563         tempcal.set(Y, Calendar.AUGUST, 10);\r
1564         d[11] = tempcal.getTime();\r
1565         tempcal.set(Y, Calendar.DECEMBER, 7);\r
1566         d[12] = tempcal.getTime();\r
1567 \r
1568         Object[] FIELD_DATA = {\r
1569             // Add new test cases as needed.\r
1570 \r
1571             // 0\r
1572             new int[] {}, d[0],\r
1573             // 1\r
1574             new int[] { Calendar.MONTH, Calendar.MARCH }, d[1],\r
1575             // 2\r
1576             new int[] { Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY }, d[2],\r
1577             // 3\r
1578             new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,\r
1579                         Calendar.DAY_OF_MONTH, 18, }, d[3],\r
1580             // 4\r
1581             new int[] { Calendar.DAY_OF_MONTH, 18,\r
1582                         Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[4],\r
1583             // 5 (WOM -1 is in previous month)\r
1584             new int[] { Calendar.DAY_OF_MONTH, 18,\r
1585                         Calendar.WEEK_OF_MONTH, -1,\r
1586                         Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[5],\r
1587             // 6\r
1588             new int[] { Calendar.DAY_OF_MONTH, 18,\r
1589                         Calendar.WEEK_OF_MONTH, 4,\r
1590                         Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[6],\r
1591             // 7 (DIM -1 is in same month)\r
1592             new int[] { Calendar.DAY_OF_MONTH, 18,\r
1593                         Calendar.DAY_OF_WEEK_IN_MONTH, -1,\r
1594                         Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[7],\r
1595             // 8\r
1596             new int[] { Calendar.WEEK_OF_YEAR, 9,\r
1597                         Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY, }, d[8],\r
1598             // 9\r
1599             new int[] { Calendar.MONTH, Calendar.OCTOBER,\r
1600                         Calendar.DAY_OF_WEEK_IN_MONTH, 1,\r
1601                         Calendar.DAY_OF_WEEK, Calendar.FRIDAY, }, d[9],\r
1602             // 10\r
1603             new int[] { Calendar.MONTH, Calendar.OCTOBER,\r
1604                         Calendar.WEEK_OF_MONTH, 2,\r
1605                         Calendar.DAY_OF_WEEK, Calendar.FRIDAY, }, d[10],\r
1606             // 11\r
1607             new int[] { Calendar.MONTH, Calendar.OCTOBER,\r
1608                         Calendar.DAY_OF_MONTH, 15,\r
1609                         Calendar.DAY_OF_YEAR, 222, }, d[11],\r
1610             // 12\r
1611             new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,\r
1612                         Calendar.MONTH, Calendar.DECEMBER, }, d[12],\r
1613         };\r
1614 \r
1615         for (int i=0; i<FIELD_DATA.length; i+=2) {\r
1616             int[] fields = (int[]) FIELD_DATA[i];\r
1617             Date exp = (Date) FIELD_DATA[i+1];\r
1618             \r
1619             cal.clear();\r
1620             cal.set(Calendar.YEAR, Y);\r
1621             for (int j=0; j<fields.length; j+=2) {\r
1622                 cal.set(fields[j], fields[j+1]);\r
1623             }\r
1624             \r
1625             Date act = cal.getTime();\r
1626             if (!act.equals(exp)) {\r
1627                 errln("FAIL: Test " + (i/2) + " got " + act +\r
1628                       ", want " + exp +\r
1629                       " (see test/java/util/Calendar/CalendarRegression.java");\r
1630             }\r
1631         }\r
1632 \r
1633         tempcal.set(1997, Calendar.JANUARY, 5);\r
1634         d[0] = tempcal.getTime();\r
1635         tempcal.set(1997, Calendar.JANUARY, 26);\r
1636         d[1] = tempcal.getTime();\r
1637         tempcal.set(1997, Calendar.FEBRUARY, 23);\r
1638         d[2] = tempcal.getTime();\r
1639         tempcal.set(1997, Calendar.JANUARY, 26);\r
1640         d[3] = tempcal.getTime();\r
1641         tempcal.set(1997, Calendar.JANUARY, 5);\r
1642         d[4] = tempcal.getTime();\r
1643         tempcal.set(1996, Calendar.DECEMBER, 8);\r
1644         d[5] = tempcal.getTime();\r
1645         // Test specific failure reported in bug\r
1646         Object[] DATA = { \r
1647             new Integer(1), d[0], new Integer(4), d[1],\r
1648             new Integer(8), d[2], new Integer(-1), d[3],\r
1649             new Integer(-4), d[4], new Integer(-8), d[5],\r
1650         };\r
1651         for (int i=0; i<DATA.length; i+=2) {\r
1652             cal.clear();\r
1653             cal.set(Calendar.DAY_OF_WEEK_IN_MONTH,\r
1654                     ((Number) DATA[i]).intValue());\r
1655             cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);\r
1656             cal.set(Calendar.MONTH, Calendar.JANUARY);\r
1657             cal.set(Calendar.YEAR, 1997);\r
1658             Date actual = cal.getTime();\r
1659             if (!actual.equals(DATA[i+1])) {\r
1660                 errln("FAIL: Sunday " + DATA[i] +\r
1661                       " of Jan 1997 -> " + actual +\r
1662                       ", want " + DATA[i+1]);\r
1663             }\r
1664         }\r
1665     }\r
1666 \r
1667     /**\r
1668      * WEEK_OF_YEAR computed incorrectly. A failure of this test can indicate a\r
1669      * problem in several different places in the\r
1670      */\r
1671     public void Test4288792() throws Exception \r
1672     {\r
1673     TimeZone savedTZ = TimeZone.getDefault();\r
1674     TimeZone.setDefault(TimeZone.getTimeZone("GMT"));\r
1675     GregorianCalendar cal = new GregorianCalendar();\r
1676         \r
1677     for (int i = 1900; i < 2100; i++) {\r
1678         for (int j1 = 1; j1 <= 7; j1++) {\r
1679         // Loop for MinimalDaysInFirstWeek: 1..7\r
1680         for (int j = Calendar.SUNDAY; j <= Calendar.SATURDAY; j++) {\r
1681             // Loop for FirstDayOfWeek: SUNDAY..SATURDAY\r
1682             cal.clear();\r
1683             cal.setMinimalDaysInFirstWeek(j1);\r
1684             cal.setFirstDayOfWeek(j);\r
1685                     // Set the calendar to the first day of the last week\r
1686                     // of the year. This may overlap some of the start of\r
1687                     // the next year; that is, the last week of 1999 may\r
1688                     // include some of January 2000. Use the add() method\r
1689                     // to advance through the week. For each day, call\r
1690                     // get(WEEK_OF_YEAR). The result should be the same\r
1691                     // for the whole week. Note that a bug in\r
1692                     // getActualMaximum() will break this test.\r
1693             cal.set(Calendar.YEAR, i);\r
1694             int maxWeek = cal.getActualMaximum(Calendar.WEEK_OF_YEAR);\r
1695             cal.set(Calendar.WEEK_OF_YEAR, maxWeek);\r
1696             cal.set(Calendar.DAY_OF_WEEK, j);\r
1697             for (int k = 1; k < 7; k++) {\r
1698             cal.add(Calendar.DATE, 1);\r
1699             int WOY = cal.get(Calendar.WEEK_OF_YEAR);\r
1700             if (WOY != maxWeek) {\r
1701                 errln(cal.getTime() + ",got=" + WOY\r
1702                   + ",expected=" + maxWeek \r
1703                   + ",min=" + j1 + ",first=" + j);\r
1704             }\r
1705             }\r
1706                     // Now advance the calendar one more day. This should\r
1707                     // put it at the first day of week 1 of the next year.\r
1708             cal.add(Calendar.DATE, 1);\r
1709             int WOY = cal.get(Calendar.WEEK_OF_YEAR);\r
1710             if (WOY != 1) {\r
1711             errln(cal.getTime() + ",got=" + WOY \r
1712                   + ",expected=1,min=" + j1 + ",first" + j);\r
1713             }\r
1714         }\r
1715         }\r
1716     }\r
1717     TimeZone.setDefault(savedTZ);\r
1718     }\r
1719 \r
1720     /**\r
1721      * Test fieldDifference().\r
1722      */\r
1723     public void TestJ438() throws Exception {\r
1724         int DATA[] = {\r
1725             2000, Calendar.JANUARY, 20,   2010, Calendar.JUNE, 15,\r
1726             2010, Calendar.JUNE, 15,      2000, Calendar.JANUARY, 20,\r
1727             1964, Calendar.SEPTEMBER, 7,  1999, Calendar.JUNE, 4,\r
1728             1999, Calendar.JUNE, 4,       1964, Calendar.SEPTEMBER, 7,\r
1729         };\r
1730         Calendar cal = Calendar.getInstance(Locale.US);\r
1731         for (int i=0; i<DATA.length; i+=6) {\r
1732             int y1 = DATA[i];\r
1733             int m1 = DATA[i+1];\r
1734             int d1 = DATA[i+2];\r
1735             int y2 = DATA[i+3];\r
1736             int m2 = DATA[i+4];\r
1737             int d2 = DATA[i+5];\r
1738 \r
1739             cal.clear();\r
1740             cal.set(y1, m1, d1);\r
1741             Date date1 = cal.getTime();\r
1742             cal.set(y2, m2, d2);\r
1743             Date date2 = cal.getTime();\r
1744 \r
1745             cal.setTime(date1);\r
1746             int dy = cal.fieldDifference(date2, Calendar.YEAR);\r
1747             int dm = cal.fieldDifference(date2, Calendar.MONTH);\r
1748             int dd = cal.fieldDifference(date2, Calendar.DATE);\r
1749 \r
1750             logln("" + date2 + " - " + date1 + " = " +\r
1751                   dy + "y " + dm + "m " + dd + "d");\r
1752 \r
1753             cal.setTime(date1);\r
1754             cal.add(Calendar.YEAR, dy);\r
1755             cal.add(Calendar.MONTH, dm);\r
1756             cal.add(Calendar.DATE, dd);\r
1757             Date date22 = cal.getTime();\r
1758             if (!date2.equals(date22)) {\r
1759                 errln("FAIL: " + date1 + " + " +\r
1760                       dy + "y " + dm + "m " + dd + "d = " +\r
1761                       date22 + ", exp " + date2);\r
1762             } else {\r
1763                 logln("Ok: " + date1 + " + " +\r
1764                       dy + "y " + dm + "m " + dd + "d = " +\r
1765                       date22);\r
1766             }\r
1767         }\r
1768     }\r
1769     \r
1770     public void TestT5555() throws Exception\r
1771     {\r
1772         Calendar cal = Calendar.getInstance();\r
1773         \r
1774         // Set date to Wednesday, February 21, 2007\r
1775         cal.set(2007, Calendar.FEBRUARY, 21);\r
1776 \r
1777         try {\r
1778             // Advance month by three years\r
1779             cal.add(Calendar.MONTH, 36);\r
1780             \r
1781             // Move to last Wednesday of month.\r
1782             cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, -1);\r
1783             \r
1784             cal.getTime();\r
1785         } catch (Exception e) {\r
1786             errln("Got an exception calling getTime().");\r
1787         }\r
1788         \r
1789         int yy, mm, dd, ee;\r
1790         \r
1791         yy = cal.get(Calendar.YEAR);\r
1792         mm = cal.get(Calendar.MONTH);\r
1793         dd = cal.get(Calendar.DATE);\r
1794         ee = cal.get(Calendar.DAY_OF_WEEK_IN_MONTH);\r
1795         \r
1796         if (yy != 2010 || mm != Calendar.FEBRUARY || dd != 24 || ee != Calendar.WEDNESDAY) {\r
1797             errln("Got date " + yy + "/" + (mm + 1) + "/" + dd + ", expected 2010/2/24");\r
1798         }\r
1799     }\r
1800 \r
1801     /**\r
1802      * Set behavior of DST_OFFSET field. ICU4J Jitterbug 9.\r
1803      */\r
1804     public void TestJ9() {\r
1805         int HOURS = 60*60*1000;\r
1806         Calendar cal = new GregorianCalendar(TimeZone.getTimeZone("PST"),\r
1807                                              Locale.US);\r
1808 \r
1809         final int END_FIELDS = 0x1234;\r
1810 \r
1811         int[] DATA = {\r
1812             // With no explicit ZONE/DST expect 12:00 am\r
1813             Calendar.MONTH, Calendar.JUNE,\r
1814             END_FIELDS,\r
1815             0, 0, // expected hour, min\r
1816 \r
1817             // Normal ZONE/DST for June 1 Pacific is 8:00/1:00\r
1818             Calendar.MONTH, Calendar.JUNE,\r
1819             Calendar.ZONE_OFFSET, -8*HOURS,\r
1820             Calendar.DST_OFFSET, HOURS,\r
1821             END_FIELDS,\r
1822             0, 0, // expected hour, min\r
1823 \r
1824             // With ZONE/DST of 8:00/0:30 expect time of 12:30 am\r
1825             Calendar.MONTH, Calendar.JUNE,\r
1826             Calendar.ZONE_OFFSET, -8*HOURS,\r
1827             Calendar.DST_OFFSET, HOURS/2,\r
1828             END_FIELDS,\r
1829             0, 30, // expected hour, min\r
1830 \r
1831             // With ZONE/DST of 8:00/UNSET expect time of 1:00 am\r
1832             Calendar.MONTH, Calendar.JUNE,\r
1833             Calendar.ZONE_OFFSET, -8*HOURS,\r
1834             END_FIELDS,\r
1835             1, 0, // expected hour, min\r
1836 \r
1837             // With ZONE/DST of UNSET/0:30 expect 4:30 pm (day before)\r
1838             Calendar.MONTH, Calendar.JUNE,\r
1839             Calendar.DST_OFFSET, HOURS/2,\r
1840             END_FIELDS,\r
1841             16, 30, // expected hour, min\r
1842         };\r
1843 \r
1844         for (int i=0; i<DATA.length; ) {\r
1845             int start = i;\r
1846             cal.clear();\r
1847 \r
1848             // Set fields\r
1849             while (DATA[i] != END_FIELDS) {\r
1850                 cal.set(DATA[i++], DATA[i++]);\r
1851             }\r
1852             ++i; // skip over END_FIELDS\r
1853 \r
1854             // Get hour/minute\r
1855             int h = cal.get(Calendar.HOUR_OF_DAY);\r
1856             int m = cal.get(Calendar.MINUTE);\r
1857 \r
1858             // Check\r
1859             if (h != DATA[i] || m != DATA[i+1]) {\r
1860                 errln("Fail: expected " + DATA[i] + ":" + DATA[i+1] +\r
1861                       ", got " + h + ":" + m + " after:");\r
1862                 while (DATA[start] != END_FIELDS) {\r
1863                     logln("set(" + FIELD_NAME[DATA[start++]] +\r
1864                           ", " + DATA[start++] + ");");\r
1865                 }\r
1866             }\r
1867 \r
1868             i += 2; // skip over expected hour, min\r
1869         }\r
1870     }\r
1871 \r
1872     /**\r
1873      * DateFormat class mistakes date style and time style as follows: -\r
1874      * DateFormat.getDateTimeInstance takes date style as time style, and time\r
1875      * style as date style - If a Calendar is passed to\r
1876      * DateFormat.getDateInstance, it returns time instance - If a Calendar is\r
1877      * passed to DateFormat.getTimeInstance, it returns date instance\r
1878      */\r
1879     public void TestDateFormatFactoryJ26() {\r
1880         TimeZone zone = TimeZone.getDefault();\r
1881         try {\r
1882             Locale loc = Locale.US;\r
1883             TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));\r
1884             java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
1885             tempcal.set(2001, Calendar.APRIL, 5, 17, 43, 53);\r
1886             Date date = tempcal.getTime();\r
1887             Calendar cal = Calendar.getInstance(loc);\r
1888             Object[] DATA = {\r
1889                 DateFormat.getDateInstance(DateFormat.SHORT, loc),\r
1890                 "DateFormat.getDateInstance(DateFormat.SHORT, loc)",\r
1891                 "4/5/01",\r
1892 \r
1893                 DateFormat.getTimeInstance(DateFormat.SHORT, loc),\r
1894                 "DateFormat.getTimeInstance(DateFormat.SHORT, loc)",\r
1895                 "5:43 PM",\r
1896 \r
1897                 DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT, loc),\r
1898                 "DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT, loc)",\r
1899                 "Thursday, April 5, 2001 5:43 PM",\r
1900 \r
1901                 DateFormat.getDateInstance(cal, DateFormat.SHORT, loc),\r
1902                 "DateFormat.getDateInstance(cal, DateFormat.SHORT, loc)",\r
1903                 "4/5/01",\r
1904 \r
1905                 DateFormat.getTimeInstance(cal, DateFormat.SHORT, loc),\r
1906                 "DateFormat.getTimeInstance(cal, DateFormat.SHORT, loc)",\r
1907                 "5:43 PM",\r
1908 \r
1909                 DateFormat.getDateTimeInstance(cal, DateFormat.FULL, DateFormat.SHORT, loc),\r
1910                 "DateFormat.getDateTimeInstance(cal, DateFormat.FULL, DateFormat.SHORT, loc)",\r
1911                 "Thursday, April 5, 2001 5:43 PM",\r
1912             \r
1913                 cal.getDateTimeFormat(DateFormat.SHORT, DateFormat.FULL, loc),\r
1914                 "cal.getDateTimeFormat(DateFormat.SHORT, DateFormat.FULL, loc)",\r
1915                 "4/5/01 5:43:53 PM Pacific Daylight Time",\r
1916 \r
1917                 cal.getDateTimeFormat(DateFormat.FULL, DateFormat.SHORT, loc),\r
1918                 "cal.getDateTimeFormat(DateFormat.FULL, DateFormat.SHORT, loc)",\r
1919                 "Thursday, April 5, 2001 5:43 PM",\r
1920             };\r
1921             for (int i=0; i<DATA.length; i+=3) {\r
1922                 DateFormat df = (DateFormat) DATA[i];\r
1923                 String desc = (String) DATA[i+1];\r
1924                 String exp = (String) DATA[i+2];\r
1925                 String got = df.format(date);\r
1926                 if (got.equals(exp)) {\r
1927                     logln("Ok: " + desc + " => " + got);\r
1928                 } else {\r
1929                     errln("FAIL: " + desc + " => " + got + ", expected " + exp);\r
1930                 }\r
1931             }\r
1932         } finally {\r
1933             TimeZone.setDefault(zone);\r
1934         }\r
1935     }\r
1936 \r
1937     public void TestRegistration() {\r
1938         /*\r
1939          * Set names = Calendar.getCalendarFactoryNames();\r
1940          * \r
1941          * TimeZone tz = TimeZone.getDefault(); Locale loc =\r
1942          * Locale.getDefault(); Iterator iter = names.iterator(); while\r
1943          * (iter.hasNext()) { String name = (String)iter.next(); logln("Testing\r
1944          * factory: " + name);\r
1945          * \r
1946          * Calendar cal = Calendar.getInstance(tz, loc, name); logln("Calendar\r
1947          * class: " + cal.getClass());\r
1948          * \r
1949          * DateFormat fmt = cal.getDateTimeFormat(DateFormat.LONG,\r
1950          * DateFormat.LONG, loc);\r
1951          * \r
1952          * logln("Date: " + fmt.format(cal.getTime())); }\r
1953          *  // register new default for our locale logln("\nTesting\r
1954          * registration"); loc = new Locale("en", "US"); Object key =\r
1955          * Calendar.register(JapaneseCalendar.factory(), loc, true);\r
1956          * \r
1957          * loc = new Locale("en", "US", "TEST"); Calendar cal =\r
1958          * Calendar.getInstance(loc); logln("Calendar class: " +\r
1959          * cal.getClass()); DateFormat fmt =\r
1960          * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);\r
1961          * logln("Date: " + fmt.format(cal.getTime()));\r
1962          *  // force to use other default anyway logln("\nOverride\r
1963          * registration"); cal = Calendar.getInstance(tz, loc, "Gregorian"); fmt =\r
1964          * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);\r
1965          * logln("Date: " + fmt.format(cal.getTime()));\r
1966          *  // unregister default logln("\nUnregistration"); logln("Unregister\r
1967          * returned: " + Calendar.unregister(key)); cal =\r
1968          * Calendar.getInstance(tz, loc, "Gregorian"); fmt =\r
1969          * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);\r
1970          * logln("Date: " + fmt.format(cal.getTime()));\r
1971          */\r
1972     }\r
1973 \r
1974     /**\r
1975      * test serialize-and-modify.\r
1976      * @throws ClassNotFoundException \r
1977      */\r
1978     public void TestSerialization3474() {\r
1979         try {\r
1980             ByteArrayOutputStream icuStream = new ByteArrayOutputStream();\r
1981     \r
1982             logln("icu Calendar");\r
1983             \r
1984             com.ibm.icu.util.GregorianCalendar icuCalendar =\r
1985                 new com.ibm.icu.util.GregorianCalendar();\r
1986             \r
1987             icuCalendar.setTimeInMillis(1187912555931L);\r
1988             long expectMillis = 1187912520931L; // with seconds (not ms) cleared.\r
1989             \r
1990             logln("instantiated: "+icuCalendar);\r
1991             logln("getMillis: "+icuCalendar.getTimeInMillis());\r
1992             icuCalendar.set(com.ibm.icu.util.GregorianCalendar.SECOND, 0);\r
1993             logln("setSecond=0: "+icuCalendar);\r
1994             {\r
1995                 long gotMillis = icuCalendar.getTimeInMillis();\r
1996                 if(gotMillis != expectMillis) {\r
1997                     errln("expect millis "+expectMillis+" but got "+gotMillis);\r
1998                 } else {\r
1999                     logln("getMillis: "+gotMillis);\r
2000                 }\r
2001             }\r
2002             ObjectOutputStream icuOut =\r
2003                 new ObjectOutputStream(icuStream);\r
2004             icuOut.writeObject(icuCalendar);\r
2005             icuOut.flush();\r
2006             icuOut.close();\r
2007             \r
2008             ObjectInputStream icuIn =\r
2009                 new ObjectInputStream(new ByteArrayInputStream(icuStream.toByteArray()));\r
2010             icuCalendar = null;\r
2011             icuCalendar = (com.ibm.icu.util.GregorianCalendar)icuIn.readObject();\r
2012             \r
2013             logln("serialized back in: "+icuCalendar);\r
2014             {\r
2015                 long gotMillis = icuCalendar.getTimeInMillis();\r
2016                 if(gotMillis != expectMillis) {\r
2017                     errln("expect millis "+expectMillis+" but got "+gotMillis);\r
2018                 } else {\r
2019                     logln("getMillis: "+gotMillis);\r
2020                 }\r
2021             }\r
2022             \r
2023             icuCalendar.set(com.ibm.icu.util.GregorianCalendar.SECOND, 0);\r
2024                     \r
2025             logln("setSecond=0: "+icuCalendar);\r
2026             {\r
2027                 long gotMillis = icuCalendar.getTimeInMillis();\r
2028                 if(gotMillis != expectMillis) {\r
2029                     errln("expect millis "+expectMillis+" after stream and setSecond but got "+gotMillis);\r
2030                 } else {\r
2031                     logln("getMillis after stream and setSecond: "+gotMillis);\r
2032                 }\r
2033             }\r
2034         } catch(IOException e) {\r
2035             errln(e.toString());\r
2036             e.printStackTrace();\r
2037         } catch(ClassNotFoundException cnf) {\r
2038             errln(cnf.toString());\r
2039             cnf.printStackTrace();\r
2040         }\r
2041 \r
2042         // JDK works correctly, etc etc.  \r
2043 //        ByteArrayOutputStream jdkStream = new ByteArrayOutputStream();\r
2044 \r
2045 //        logln("\nSUN Calendar");\r
2046 //        \r
2047 //        java.util.GregorianCalendar sunCalendar =\r
2048 //            new java.util.GregorianCalendar();\r
2049 //        \r
2050 //        logln("instanzieren: "+sunCalendar);\r
2051 //        logln("getMillis: "+sunCalendar.getTimeInMillis());\r
2052 //        sunCalendar.set(java.util.GregorianCalendar.SECOND, 0);\r
2053 //        logln("setSecond=0: "+sunCalendar);\r
2054 //        logln("getMillis: "+sunCalendar.getTimeInMillis());\r
2055 //        \r
2056 //        ObjectOutputStream sunOut =\r
2057 //            new ObjectOutputStream(jdkStream);\r
2058 //        sunOut.writeObject(sunCalendar);\r
2059 //        sunOut.flush();\r
2060 //        sunOut.close();\r
2061 //        \r
2062 //        ObjectInputStream sunIn =\r
2063 //            new ObjectInputStream(new ByteArrayInputStream(jdkStream.toByteArray()));\r
2064 //        sunCalendar = null;\r
2065 //        sunCalendar = (java.util.GregorianCalendar)sunIn.readObject();\r
2066 //        \r
2067 //        logln("serialized: "+sunCalendar);\r
2068 //        logln("getMillis: "+sunCalendar.getTimeInMillis());\r
2069 //        \r
2070 //        sunCalendar.set(java.util.GregorianCalendar.SECOND, 0);\r
2071 //        logln("setSecond=0: "+sunCalendar);\r
2072 //        logln("getMillis: "+sunCalendar.getTimeInMillis());\r
2073         \r
2074     }\r
2075 \r
2076     public void TestYearJump3279() {\r
2077         final long time = 1041148800000L;\r
2078         Calendar c = new GregorianCalendar();\r
2079         DateFormat fmt = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, Locale.US);\r
2080 \r
2081         c.setTimeInMillis(time);\r
2082         int year1 = c.get(Calendar.YEAR);\r
2083         \r
2084         logln("time: " + fmt.format(new Date(c.getTimeInMillis())));\r
2085 \r
2086         logln("setting DOW to " + c.getFirstDayOfWeek());\r
2087         c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());\r
2088         logln("week: " + c.getTime());\r
2089         logln("week adjust: " + fmt.format(new Date(c.getTimeInMillis())));\r
2090         int year2 = c.get(Calendar.YEAR);\r
2091         \r
2092         if(year1 != year2) {\r
2093             errln("Error: adjusted day of week, and year jumped from " + year1 + " to " + year2);\r
2094         } else {\r
2095             logln("Year remained " + year2 + " - PASS.");\r
2096         }\r
2097     }\r
2098 \r
2099     public void TestGetKeywordValuesForLocale(){\r
2100 \r
2101         final String[][] PREFERRED = {\r
2102             {"root",        "gregorian"},\r
2103             {"und",         "gregorian"},\r
2104             {"en_US",       "gregorian"},\r
2105             {"en_029",      "gregorian"},\r
2106             {"th_TH",       "buddhist", "gregorian"},\r
2107             {"und_TH",      "buddhist", "gregorian"},\r
2108             {"en_TH",       "buddhist", "gregorian"},\r
2109             {"he_IL",       "gregorian", "hebrew", "islamic", "islamic-civil"},\r
2110             {"ar_EG",       "gregorian", "coptic", "islamic", "islamic-civil"},\r
2111             {"ja",          "gregorian", "japanese"},\r
2112             {"ps_Guru_IN",  "gregorian", "indian"},\r
2113             {"th@calendar=gregorian",   "buddhist", "gregorian"},\r
2114             {"en@calendar=islamic",     "gregorian"},\r
2115             {"zh_TW",       "gregorian", "roc", "chinese"},\r
2116             {"ar_IR",       "gregorian", "persian", "islamic", "islamic-civil"},\r
2117         };\r
2118 \r
2119         String[] ALL = Calendar.getKeywordValuesForLocale("calendar", ULocale.getDefault(), false);\r
2120         HashSet ALLSET = new HashSet();\r
2121         for (int i = 0; i < ALL.length; i++) {\r
2122             ALLSET.add(ALL[i]);\r
2123         }\r
2124 \r
2125         for (int i = 0; i < PREFERRED.length; i++) {\r
2126             ULocale loc = new ULocale(PREFERRED[i][0]);\r
2127             String[] expected = new String[PREFERRED[i].length - 1];\r
2128             System.arraycopy(PREFERRED[i], 1, expected, 0, expected.length);\r
2129 \r
2130             String[] pref = Calendar.getKeywordValuesForLocale("calendar", loc, true);\r
2131             boolean matchPref = false;\r
2132             if (pref.length == expected.length) {\r
2133                 matchPref = true;\r
2134                 for (int j = 0; j < pref.length; j++) {\r
2135                     if (!pref[j].equals(expected[j])) {\r
2136                         matchPref = false;\r
2137                     }\r
2138                 }\r
2139             }\r
2140             if (!matchPref) {\r
2141                 errln("FAIL: Preferred values for locale " + loc \r
2142                         + " got:" + Utility.arrayToString(pref) + " expected:" + Utility.arrayToString(expected));\r
2143             }\r
2144 \r
2145             String[] all = Calendar.getKeywordValuesForLocale("calendar", loc, false);\r
2146             boolean matchAll = false;\r
2147             if (all.length == ALLSET.size()) {\r
2148                 matchAll = true;\r
2149                 for (int j = 0; j < all.length; j++) {\r
2150                     if (!ALLSET.contains(all[j])) {\r
2151                         matchAll = false;\r
2152                         break;\r
2153                     }\r
2154                 }\r
2155             }\r
2156             if (!matchAll) {\r
2157                 errln("FAIL: All values for locale " + loc\r
2158                         + " got:" + Utility.arrayToString(all)); \r
2159             }\r
2160         }\r
2161     }\r
2162 \r
2163 }\r
2164 \r
2165 //eof\r